[libcxx-commits] [libcxx] 344cef6 - [libc++] Granularize the <random> header. NFCI.
Arthur O'Dwyer via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Nov 22 10:24:45 PST 2021
Author: Arthur O'Dwyer
Date: 2021-11-22T13:24:27-05:00
New Revision: 344cef6695e9af05ed9fa5bb96b3a475c7a4df4b
URL: https://github.com/llvm/llvm-project/commit/344cef6695e9af05ed9fa5bb96b3a475c7a4df4b
DIFF: https://github.com/llvm/llvm-project/commit/344cef6695e9af05ed9fa5bb96b3a475c7a4df4b.diff
LOG: [libc++] Granularize the <random> header. NFCI.
Actually there's one functional change here, which is that users can
no longer depend on <random> to include all of C++20 <concepts>. That
inclusion is so new that we believe nobody should be depending on it
yet, even in the presence of Hyrum's Law. We keep the includes of <vector>,
<algorithm>, etc., so as not to break pre-C++20 Hyrum's Law users.
Differential Revision: https://reviews.llvm.org/D114281
Added:
libcxx/include/__random/bernoulli_distribution.h
libcxx/include/__random/binomial_distribution.h
libcxx/include/__random/cauchy_distribution.h
libcxx/include/__random/chi_squared_distribution.h
libcxx/include/__random/default_random_engine.h
libcxx/include/__random/discard_block_engine.h
libcxx/include/__random/discrete_distribution.h
libcxx/include/__random/exponential_distribution.h
libcxx/include/__random/extreme_value_distribution.h
libcxx/include/__random/fisher_f_distribution.h
libcxx/include/__random/gamma_distribution.h
libcxx/include/__random/generate_canonical.h
libcxx/include/__random/geometric_distribution.h
libcxx/include/__random/independent_bits_engine.h
libcxx/include/__random/is_seed_sequence.h
libcxx/include/__random/knuth_b.h
libcxx/include/__random/linear_congruential_engine.h
libcxx/include/__random/log2.h
libcxx/include/__random/lognormal_distribution.h
libcxx/include/__random/mersenne_twister_engine.h
libcxx/include/__random/negative_binomial_distribution.h
libcxx/include/__random/normal_distribution.h
libcxx/include/__random/piecewise_constant_distribution.h
libcxx/include/__random/piecewise_linear_distribution.h
libcxx/include/__random/poisson_distribution.h
libcxx/include/__random/random_device.h
libcxx/include/__random/ranlux.h
libcxx/include/__random/seed_seq.h
libcxx/include/__random/shuffle_order_engine.h
libcxx/include/__random/student_t_distribution.h
libcxx/include/__random/subtract_with_carry_engine.h
libcxx/include/__random/uniform_random_bit_generator.h
libcxx/include/__random/uniform_real_distribution.h
libcxx/include/__random/weibull_distribution.h
libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp
libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp
Modified:
libcxx/include/CMakeLists.txt
libcxx/include/__random/uniform_int_distribution.h
libcxx/include/module.modulemap
libcxx/include/random
libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp
Removed:
################################################################################
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index cd5674a018e80..ac6038bda94d7 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -236,7 +236,41 @@ set(files
__mutex_base
__node_handle
__nullptr
+ __random/bernoulli_distribution.h
+ __random/binomial_distribution.h
+ __random/cauchy_distribution.h
+ __random/chi_squared_distribution.h
+ __random/default_random_engine.h
+ __random/discard_block_engine.h
+ __random/discrete_distribution.h
+ __random/exponential_distribution.h
+ __random/extreme_value_distribution.h
+ __random/fisher_f_distribution.h
+ __random/gamma_distribution.h
+ __random/generate_canonical.h
+ __random/geometric_distribution.h
+ __random/independent_bits_engine.h
+ __random/is_seed_sequence.h
+ __random/knuth_b.h
+ __random/linear_congruential_engine.h
+ __random/log2.h
+ __random/lognormal_distribution.h
+ __random/mersenne_twister_engine.h
+ __random/negative_binomial_distribution.h
+ __random/normal_distribution.h
+ __random/piecewise_constant_distribution.h
+ __random/piecewise_linear_distribution.h
+ __random/poisson_distribution.h
+ __random/random_device.h
+ __random/ranlux.h
+ __random/seed_seq.h
+ __random/shuffle_order_engine.h
+ __random/student_t_distribution.h
+ __random/subtract_with_carry_engine.h
__random/uniform_int_distribution.h
+ __random/uniform_random_bit_generator.h
+ __random/uniform_real_distribution.h
+ __random/weibull_distribution.h
__ranges/access.h
__ranges/all.h
__ranges/common_view.h
diff --git a/libcxx/include/__random/bernoulli_distribution.h b/libcxx/include/__random/bernoulli_distribution.h
new file mode 100644
index 0000000000000..60ae5eae70333
--- /dev/null
+++ b/libcxx/include/__random/bernoulli_distribution.h
@@ -0,0 +1,143 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
+{
+public:
+ // types
+ typedef bool result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ double __p_;
+ public:
+ typedef bernoulli_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(double __p = 0.5) : __p_(__p) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ bernoulli_distribution() : bernoulli_distribution(0.5) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_.p();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return false;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return true;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const bernoulli_distribution& __x,
+ const bernoulli_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const bernoulli_distribution& __x,
+ const bernoulli_distribution& __y)
+ {return !(__x == __y);}
+};
+
+template<class _URNG>
+inline
+bernoulli_distribution::result_type
+bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
+{
+ uniform_real_distribution<double> __gen;
+ return __gen(__g) < __p.p();
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ return __os << __x.p();
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
+{
+ typedef bernoulli_distribution _Eng;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ double __p;
+ __is >> __p;
+ if (!__is.fail())
+ __x.param(param_type(__p));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_BERNOULLI_DISTRIBUTION_H
diff --git a/libcxx/include/__random/binomial_distribution.h b/libcxx/include/__random/binomial_distribution.h
new file mode 100644
index 0000000000000..9662de8befd9c
--- /dev/null
+++ b/libcxx/include/__random/binomial_distribution.h
@@ -0,0 +1,225 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS binomial_distribution
+{
+public:
+ // types
+ typedef _IntType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __t_;
+ double __p_;
+ double __pr_;
+ double __odds_ratio_;
+ result_type __r0_;
+ public:
+ typedef binomial_distribution distribution_type;
+
+ explicit param_type(result_type __t = 1, double __p = 0.5);
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type t() const {return __t_;}
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+
+ friend class binomial_distribution;
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ binomial_distribution() : binomial_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit binomial_distribution(result_type __t, double __p = 0.5)
+ : __p_(param_type(__t, __p)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
+ : __p_(param_type(__t, __p)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type t() const {return __p_.t();}
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_.p();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return t();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const binomial_distribution& __x,
+ const binomial_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const binomial_distribution& __x,
+ const binomial_distribution& __y)
+ {return !(__x == __y);}
+};
+
+#ifndef _LIBCPP_MSVCRT_LIKE
+extern "C" double lgamma_r(double, int *);
+#endif
+
+inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
+#if defined(_LIBCPP_MSVCRT_LIKE)
+ return lgamma(__d);
+#else
+ int __sign;
+ return lgamma_r(__d, &__sign);
+#endif
+}
+
+template<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(__libcpp_lgamma(__t_ + 1.) -
+ __libcpp_lgamma(__r0_ + 1.) -
+ __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
+ (__t_ - __r0_) * _VSTD::log(1 - __p_));
+ __odds_ratio_ = __p_ / (1 - __p_);
+ }
+}
+
+// Reference: Kemp, C.D. (1986). `A modal method for generating binomial
+// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
+template<class _IntType>
+template<class _URNG>
+_IntType
+binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
+{
+ if (__pr.__t_ == 0 || __pr.__p_ == 0)
+ return 0;
+ if (__pr.__p_ == 1)
+ return __pr.__t_;
+ uniform_real_distribution<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>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const binomial_distribution<_IntType>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ return __os << __x.t() << __sp << __x.p();
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ binomial_distribution<_IntType>& __x)
+{
+ typedef binomial_distribution<_IntType> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __t;
+ double __p;
+ __is >> __t >> __p;
+ if (!__is.fail())
+ __x.param(param_type(__t, __p));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/cauchy_distribution.h b/libcxx/include/__random/cauchy_distribution.h
new file mode 100644
index 0000000000000..6661e00bf939c
--- /dev/null
+++ b/libcxx/include/__random/cauchy_distribution.h
@@ -0,0 +1,162 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS cauchy_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __a_;
+ result_type __b_;
+ public:
+ typedef cauchy_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __a = 0, result_type __b = 1)
+ : __a_(__a), __b_(__b) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __a_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __b_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ cauchy_distribution() : cauchy_distribution(0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit cauchy_distribution(result_type __a, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit cauchy_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __p_.a();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __p_.b();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return -numeric_limits<result_type>::infinity();}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+};
+
+template <class _RealType>
+template<class _URNG>
+inline
+_RealType
+cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ 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 _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const cauchy_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.a() << __sp << __x.b();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ cauchy_distribution<_RT>& __x)
+{
+ typedef cauchy_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __a;
+ result_type __b;
+ __is >> __a >> __b;
+ if (!__is.fail())
+ __x.param(param_type(__a, __b));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
diff --git a/libcxx/include/__random/chi_squared_distribution.h b/libcxx/include/__random/chi_squared_distribution.h
new file mode 100644
index 0000000000000..9cf38971bddec
--- /dev/null
+++ b/libcxx/include/__random/chi_squared_distribution.h
@@ -0,0 +1,144 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/gamma_distribution.h>
+#include <limits>
+#include <iosfwd>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __n_;
+ public:
+ typedef chi_squared_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __n = 1) : __n_(__n) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __n_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__n_ == __y.__n_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ chi_squared_distribution() : chi_squared_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit chi_squared_distribution(result_type __n)
+ : __p_(param_type(__n)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit chi_squared_distribution(result_type __n = 1)
+ : __p_(param_type(__n)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit chi_squared_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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);}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __p_.n();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const chi_squared_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ __os << __x.n();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ chi_squared_distribution<_RT>& __x)
+{
+ typedef chi_squared_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __n;
+ __is >> __n;
+ if (!__is.fail())
+ __x.param(param_type(__n));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_CHI_SQUARED_DISTRIBUTION_H
diff --git a/libcxx/include/__random/default_random_engine.h b/libcxx/include/__random/default_random_engine.h
new file mode 100644
index 0000000000000..61c5cf9c7142f
--- /dev/null
+++ b/libcxx/include/__random/default_random_engine.h
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H
+#define _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H
+
+#include <__config>
+#include <__random/linear_congruential_engine.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+typedef minstd_rand default_random_engine;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_DEFAULT_RANDOM_ENGINE_H
diff --git a/libcxx/include/__random/discard_block_engine.h b/libcxx/include/__random/discard_block_engine.h
new file mode 100644
index 0000000000000..3357152118845
--- /dev/null
+++ b/libcxx/include/__random/discard_block_engine.h
@@ -0,0 +1,203 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
+#define _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
+
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <__utility/move.h>
+#include <climits>
+#include <iosfwd>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _Engine, size_t __p, size_t __r>
+class _LIBCPP_TEMPLATE_VIS discard_block_engine
+{
+ _Engine __e_;
+ int __n_;
+
+ static_assert( 0 < __r, "discard_block_engine invalid parameters");
+ static_assert(__r <= __p, "discard_block_engine invalid parameters");
+ static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters");
+public:
+ // types
+ typedef typename _Engine::result_type result_type;
+
+ // engine characteristics
+ static _LIBCPP_CONSTEXPR const size_t block_size = __p;
+ static _LIBCPP_CONSTEXPR const size_t used_block = __r;
+
+#ifdef _LIBCPP_CXX03_LANG
+ static const result_type _Min = _Engine::_Min;
+ static const result_type _Max = _Engine::_Max;
+#else
+ static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
+ static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
+#endif
+
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
+
+ // constructors and seeding functions
+ _LIBCPP_INLINE_VISIBILITY
+ discard_block_engine() : __n_(0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit discard_block_engine(const _Engine& __e)
+ : __e_(__e), __n_(0) {}
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit discard_block_engine(_Engine&& __e)
+ : __e_(_VSTD::move(__e)), __n_(0) {}
+#endif // _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
+ template<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;}
+
+ // generating functions
+ result_type operator()();
+ _LIBCPP_INLINE_VISIBILITY
+ void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ const _Engine& base() const _NOEXCEPT {return __e_;}
+
+ template<class _Eng, size_t _Pp, size_t _Rp>
+ friend
+ bool
+ operator==(
+ const discard_block_engine<_Eng, _Pp, _Rp>& __x,
+ const discard_block_engine<_Eng, _Pp, _Rp>& __y);
+
+ template<class _Eng, size_t _Pp, size_t _Rp>
+ friend
+ bool
+ operator!=(
+ const discard_block_engine<_Eng, _Pp, _Rp>& __x,
+ const discard_block_engine<_Eng, _Pp, _Rp>& __y);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Pp, size_t _Rp>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const discard_block_engine<_Eng, _Pp, _Rp>& __x);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Pp, size_t _Rp>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ discard_block_engine<_Eng, _Pp, _Rp>& __x);
+};
+
+template<class _Engine, size_t __p, size_t __r>
+ _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
+
+template<class _Engine, size_t __p, size_t __r>
+ _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
+
+template<class _Engine, size_t __p, size_t __r>
+typename discard_block_engine<_Engine, __p, __r>::result_type
+discard_block_engine<_Engine, __p, __r>::operator()()
+{
+ if (__n_ >= static_cast<int>(__r))
+ {
+ __e_.discard(__p - __r);
+ __n_ = 0;
+ }
+ ++__n_;
+ return __e_();
+}
+
+template<class _Eng, size_t _Pp, size_t _Rp>
+inline _LIBCPP_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_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 _CharT, class _Traits,
+ class _Eng, size_t _Pp, size_t _Rp>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const discard_block_engine<_Eng, _Pp, _Rp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _Ostream;
+ __os.flags(_Ostream::dec | _Ostream::left);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ return __os << __x.__e_ << __sp << __x.__n_;
+}
+
+template <class _CharT, class _Traits,
+ class _Eng, size_t _Pp, size_t _Rp>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ discard_block_engine<_Eng, _Pp, _Rp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ _Eng __e;
+ int __n;
+ __is >> __e >> __n;
+ if (!__is.fail())
+ {
+ __x.__e_ = __e;
+ __x.__n_ = __n;
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_DISCARD_BLOCK_ENGINE_H
diff --git a/libcxx/include/__random/discrete_distribution.h b/libcxx/include/__random/discrete_distribution.h
new file mode 100644
index 0000000000000..dc9881a92c387
--- /dev/null
+++ b/libcxx/include/__random/discrete_distribution.h
@@ -0,0 +1,260 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
+
+#include <__algorithm/upper_bound.h>
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <cstddef>
+#include <iosfwd>
+#include <numeric>
+#include <vector>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS discrete_distribution
+{
+public:
+ // types
+ typedef _IntType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ vector<double> __p_;
+ public:
+ typedef discrete_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type() {}
+ template<class _InputIterator>
+ _LIBCPP_INLINE_VISIBILITY
+ 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();}
+#endif // _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ param_type(size_t __nw, double __xmin, double __xmax,
+ _UnaryOperation __fw);
+
+ 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);}
+
+ private:
+ void __init();
+
+ friend class discrete_distribution;
+
+ template <class _CharT, class _Traits, class _IT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const discrete_distribution<_IT>& __x);
+
+ template <class _CharT, class _Traits, class _IT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ discrete_distribution<_IT>& __x);
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+ _LIBCPP_INLINE_VISIBILITY
+ discrete_distribution() {}
+ template<class _InputIterator>
+ _LIBCPP_INLINE_VISIBILITY
+ discrete_distribution(_InputIterator __f, _InputIterator __l)
+ : __p_(__f, __l) {}
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ 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() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ 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_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return __p_.__p_.size();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const discrete_distribution& __x,
+ const discrete_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const discrete_distribution& __x,
+ const discrete_distribution& __y)
+ {return !(__x == __y);}
+
+ template <class _CharT, class _Traits, class _IT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const discrete_distribution<_IT>& __x);
+
+ template <class _CharT, class _Traits, class _IT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ discrete_distribution<_IT>& __x);
+};
+
+template<class _IntType>
+template<class _UnaryOperation>
+discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
+ double __xmin,
+ double __xmax,
+ _UnaryOperation __fw)
+{
+ if (__nw > 1)
+ {
+ __p_.reserve(__nw - 1);
+ double __d = (__xmax - __xmin) / __nw;
+ double __d2 = __d / 2;
+ for (size_t __k = 0; __k < __nw; ++__k)
+ __p_.push_back(__fw(__xmin + __k * __d + __d2));
+ __init();
+ }
+}
+
+template<class _IntType>
+void
+discrete_distribution<_IntType>::param_type::__init()
+{
+ if (!__p_.empty())
+ {
+ if (__p_.size() > 1)
+ {
+ double __s = _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);
+ _VSTD::adjacent_
diff erence(__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)
+{
+ 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 _CharT, class _Traits, class _IT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const discrete_distribution<_IT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ size_t __n = __x.__p_.__p_.size();
+ __os << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__p_[__i];
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _IT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ discrete_distribution<_IT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ size_t __n;
+ __is >> __n;
+ vector<double> __p(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __p[__i];
+ if (!__is.fail())
+ swap(__x.__p_.__p_, __p);
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_DISCRETE_DISTRIBUTION_H
diff --git a/libcxx/include/__random/exponential_distribution.h b/libcxx/include/__random/exponential_distribution.h
new file mode 100644
index 0000000000000..9e555f0c10756
--- /dev/null
+++ b/libcxx/include/__random/exponential_distribution.h
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/generate_canonical.h>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS exponential_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __lambda_;
+ public:
+ typedef exponential_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type lambda() const {return __lambda_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__lambda_ == __y.__lambda_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ exponential_distribution() : exponential_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit exponential_distribution(result_type __lambda)
+ : __p_(param_type(__lambda)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit exponential_distribution(result_type __lambda = 1)
+ : __p_(param_type(__lambda)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type lambda() const {return __p_.lambda();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _RealType>
+template<class _URNG>
+_RealType
+exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ return -_VSTD::log
+ (
+ result_type(1) -
+ _VSTD::generate_canonical<result_type,
+ numeric_limits<result_type>::digits>(__g)
+ )
+ / __p.lambda();
+}
+
+template <class _CharT, class _Traits, class _RealType>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const exponential_distribution<_RealType>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ return __os << __x.lambda();
+}
+
+template <class _CharT, class _Traits, class _RealType>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ exponential_distribution<_RealType>& __x)
+{
+ typedef exponential_distribution<_RealType> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __lambda;
+ __is >> __lambda;
+ if (!__is.fail())
+ __x.param(param_type(__lambda));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_EXPONENTIAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/extreme_value_distribution.h b/libcxx/include/__random/extreme_value_distribution.h
new file mode 100644
index 0000000000000..0e200f91d7ff4
--- /dev/null
+++ b/libcxx/include/__random/extreme_value_distribution.h
@@ -0,0 +1,161 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __a_;
+ result_type __b_;
+ public:
+ typedef extreme_value_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __a = 0, result_type __b = 1)
+ : __a_(__a), __b_(__b) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __a_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __b_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ extreme_value_distribution() : extreme_value_distribution(0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit extreme_value_distribution(result_type __a, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit extreme_value_distribution(result_type __a = 0,
+ result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit extreme_value_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __p_.a();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __p_.b();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return -numeric_limits<result_type>::infinity();}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+};
+
+template<class _RealType>
+template<class _URNG>
+_RealType
+extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ return __p.a() - __p.b() *
+ _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const extreme_value_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.a() << __sp << __x.b();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ extreme_value_distribution<_RT>& __x)
+{
+ typedef extreme_value_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __a;
+ result_type __b;
+ __is >> __a >> __b;
+ if (!__is.fail())
+ __x.param(param_type(__a, __b));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
diff --git a/libcxx/include/__random/fisher_f_distribution.h b/libcxx/include/__random/fisher_f_distribution.h
new file mode 100644
index 0000000000000..bf64d33a645ac
--- /dev/null
+++ b/libcxx/include/__random/fisher_f_distribution.h
@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/gamma_distribution.h>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __m_;
+ result_type __n_;
+ public:
+ typedef fisher_f_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __m = 1, result_type __n = 1)
+ : __m_(__m), __n_(__n) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type m() const {return __m_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __n_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ fisher_f_distribution() : fisher_f_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit fisher_f_distribution(result_type __m, result_type __n = 1)
+ : __p_(param_type(__m, __n)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
+ : __p_(param_type(__m, __n)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit fisher_f_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type m() const {return __p_.m();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __p_.n();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _RealType>
+template<class _URNG>
+_RealType
+fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ 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>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const fisher_f_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.m() << __sp << __x.n();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ fisher_f_distribution<_RT>& __x)
+{
+ typedef fisher_f_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __m;
+ result_type __n;
+ __is >> __m >> __n;
+ if (!__is.fail())
+ __x.param(param_type(__m, __n));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_FISHER_F_DISTRIBUTION_H
diff --git a/libcxx/include/__random/gamma_distribution.h b/libcxx/include/__random/gamma_distribution.h
new file mode 100644
index 0000000000000..49d024eafea25
--- /dev/null
+++ b/libcxx/include/__random/gamma_distribution.h
@@ -0,0 +1,213 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <__random/exponential_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS gamma_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __alpha_;
+ result_type __beta_;
+ public:
+ typedef gamma_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __alpha = 1, result_type __beta = 1)
+ : __alpha_(__alpha), __beta_(__beta) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type alpha() const {return __alpha_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type beta() const {return __beta_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ gamma_distribution() : gamma_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
+ : __p_(param_type(__alpha, __beta)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit gamma_distribution(result_type __alpha = 1,
+ result_type __beta = 1)
+ : __p_(param_type(__alpha, __beta)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit gamma_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type alpha() const {return __p_.alpha();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type beta() const {return __p_.beta();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _RealType>
+template<class _URNG>
+_RealType
+gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ 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;
+ }
+ }
+ }
+ }
+ else // __a < 1
+ {
+ while (true)
+ {
+ const result_type __u = __gen(__g);
+ const result_type __es = __egen(__g);
+ if (__u <= 1 - __a)
+ {
+ __x = _VSTD::pow(__u, 1 / __a);
+ if (__x <= __es)
+ break;
+ }
+ else
+ {
+ const result_type __e = -_VSTD::log((1-__u)/__a);
+ __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
+ if (__x <= __e + __es)
+ break;
+ }
+ }
+ }
+ return __x * __p.beta();
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const gamma_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.alpha() << __sp << __x.beta();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ gamma_distribution<_RT>& __x)
+{
+ typedef gamma_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __alpha;
+ result_type __beta;
+ __is >> __alpha >> __beta;
+ if (!__is.fail())
+ __x.param(param_type(__alpha, __beta));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
diff --git a/libcxx/include/__random/generate_canonical.h b/libcxx/include/__random/generate_canonical.h
new file mode 100644
index 0000000000000..46c3b29809521
--- /dev/null
+++ b/libcxx/include/__random/generate_canonical.h
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_GENERATE_CANONICAL_H
+#define _LIBCPP___RANDOM_GENERATE_CANONICAL_H
+
+#include <__config>
+#include <__random/log2.h>
+#include <cstdint>
+#include <initializer_list>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// generate_canonical
+
+template<class _RealType, size_t __bits, class _URNG>
+_RealType
+generate_canonical(_URNG& __g)
+{
+ const size_t _Dt = numeric_limits<_RealType>::digits;
+ const size_t __b = _Dt < __bits ? _Dt : __bits;
+#ifdef _LIBCPP_CXX03_LANG
+ const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
+#else
+ const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
+#endif
+ const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
+ const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
+ _RealType __base = _Rp;
+ _RealType _Sp = __g() - _URNG::min();
+ for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
+ _Sp += (__g() - _URNG::min()) * __base;
+ return _Sp / __base;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_GENERATE_CANONICAL_H
diff --git a/libcxx/include/__random/geometric_distribution.h b/libcxx/include/__random/geometric_distribution.h
new file mode 100644
index 0000000000000..174914eaed2ee
--- /dev/null
+++ b/libcxx/include/__random/geometric_distribution.h
@@ -0,0 +1,141 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/negative_binomial_distribution.h>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS geometric_distribution
+{
+public:
+ // types
+ typedef _IntType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ double __p_;
+ public:
+ typedef geometric_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(double __p = 0.5) : __p_(__p) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ geometric_distribution() : geometric_distribution(0.5) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit geometric_distribution(double __p)
+ : __p_(__p) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit geometric_distribution(double __p = 0.5)
+ : __p_(__p) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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);}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_.p();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _CharT, class _Traits, class _IntType>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const geometric_distribution<_IntType>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ return __os << __x.p();
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ geometric_distribution<_IntType>& __x)
+{
+ typedef geometric_distribution<_IntType> _Eng;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ double __p;
+ __is >> __p;
+ if (!__is.fail())
+ __x.param(param_type(__p));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_GEOMETRIC_DISTRIBUTION_H
diff --git a/libcxx/include/__random/independent_bits_engine.h b/libcxx/include/__random/independent_bits_engine.h
new file mode 100644
index 0000000000000..f0e8c654246b2
--- /dev/null
+++ b/libcxx/include/__random/independent_bits_engine.h
@@ -0,0 +1,271 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
+#define _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
+
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <__random/log2.h>
+#include <__utility/move.h>
+#include <iosfwd>
+#include <limits>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _Engine, size_t __w, class _UIntType>
+class _LIBCPP_TEMPLATE_VIS independent_bits_engine
+{
+ template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
+ class __get_n
+ {
+ static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
+ static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
+ static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
+ static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
+ public:
+ static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
+ };
+public:
+ // types
+ typedef _UIntType result_type;
+
+private:
+ _Engine __e_;
+
+ static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+ static_assert( 0 < __w, "independent_bits_engine invalid parameters");
+ static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
+
+ typedef typename _Engine::result_type _Engine_result_type;
+ typedef typename conditional
+ <
+ sizeof(_Engine_result_type) <= sizeof(result_type),
+ result_type,
+ _Engine_result_type
+ >::type _Working_result_type;
+#ifdef _LIBCPP_CXX03_LANG
+ static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
+ + _Working_result_type(1);
+#else
+ static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
+ + _Working_result_type(1);
+#endif
+ static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
+ static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
+ static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
+ static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
+ static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
+ static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
+ static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
+ (_Rp >> __w0) << __w0;
+ static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
+ (_Rp >> (__w0+1)) << (__w0+1);
+ static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
+ _Engine_result_type(~0) >> (_EDt - __w0) :
+ _Engine_result_type(0);
+ static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
+ _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
+ _Engine_result_type(~0);
+public:
+ static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+ static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
+ (result_type(1) << __w) - result_type(1);
+ static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
+
+ // engine characteristics
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+
+ // constructors and seeding functions
+ _LIBCPP_INLINE_VISIBILITY
+ independent_bits_engine() {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit independent_bits_engine(const _Engine& __e)
+ : __e_(__e) {}
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit independent_bits_engine(_Engine&& __e)
+ : __e_(_VSTD::move(__e)) {}
+#endif // _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
+ template<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);}
+
+ // 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()();}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ const _Engine& base() const _NOEXCEPT {return __e_;}
+
+ template<class _Eng, size_t _Wp, class _UInt>
+ friend
+ bool
+ operator==(
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
+
+ template<class _Eng, size_t _Wp, class _UInt>
+ friend
+ bool
+ operator!=(
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Wp, class _UInt>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Wp, class _UInt>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+
+private:
+ _LIBCPP_INLINE_VISIBILITY
+ result_type __eval(false_type);
+ 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>
+ _LIBCPP_INLINE_VISIBILITY
+ static
+ typename enable_if
+ <
+ (__count >= _Dt),
+ result_type
+ >::type
+ __lshift(result_type) {return result_type(0);}
+};
+
+template<class _Engine, size_t __w, class _UIntType>
+inline
+_UIntType
+independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
+{
+ return static_cast<result_type>(__e_() & __mask0);
+}
+
+template<class _Engine, size_t __w, class _UIntType>
+_UIntType
+independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
+{
+ result_type _Sp = 0;
+ for (size_t __k = 0; __k < __n0; ++__k)
+ {
+ _Engine_result_type __u;
+ do
+ {
+ __u = __e_() - _Engine::min();
+ } while (__u >= __y0);
+ _Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
+ }
+ for (size_t __k = __n0; __k < __n; ++__k)
+ {
+ _Engine_result_type __u;
+ do
+ {
+ __u = __e_() - _Engine::min();
+ } while (__u >= __y1);
+ _Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
+ }
+ return _Sp;
+}
+
+template<class _Eng, size_t _Wp, class _UInt>
+inline _LIBCPP_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_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 _CharT, class _Traits,
+ class _Eng, size_t _Wp, class _UInt>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
+{
+ return __os << __x.base();
+}
+
+template <class _CharT, class _Traits,
+ class _Eng, size_t _Wp, class _UInt>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ independent_bits_engine<_Eng, _Wp, _UInt>& __x)
+{
+ _Eng __e;
+ __is >> __e;
+ if (!__is.fail())
+ __x.__e_ = __e;
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
diff --git a/libcxx/include/__random/is_seed_sequence.h b/libcxx/include/__random/is_seed_sequence.h
new file mode 100644
index 0000000000000..46b1d719ddfb4
--- /dev/null
+++ b/libcxx/include/__random/is_seed_sequence.h
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H
+#define _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H
+
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Sseq, class _Engine>
+struct __is_seed_sequence
+{
+ static _LIBCPP_CONSTEXPR const bool value =
+ !is_convertible<_Sseq, typename _Engine::result_type>::value &&
+ !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_IS_SEED_SEQUENCE_H
diff --git a/libcxx/include/__random/knuth_b.h b/libcxx/include/__random/knuth_b.h
new file mode 100644
index 0000000000000..ade853884dd37
--- /dev/null
+++ b/libcxx/include/__random/knuth_b.h
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_KNUTH_B_H
+#define _LIBCPP___RANDOM_KNUTH_B_H
+
+#include <__config>
+#include <__random/linear_congruential_engine.h>
+#include <__random/shuffle_order_engine.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_KNUTH_B_H
diff --git a/libcxx/include/__random/linear_congruential_engine.h b/libcxx/include/__random/linear_congruential_engine.h
new file mode 100644
index 0000000000000..64c9f584114c7
--- /dev/null
+++ b/libcxx/include/__random/linear_congruential_engine.h
@@ -0,0 +1,398 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H
+#define _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H
+
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <cstdint>
+#include <iosfwd>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_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;
+};
+
+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>
+struct __lce_ta;
+
+// 64
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+// 32
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+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;
+ }
+};
+
+// 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 <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>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
+{
+public:
+ // types
+ typedef _UIntType result_type;
+
+private:
+ result_type __x_;
+
+ static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
+
+ static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
+ static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
+ static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
+public:
+ static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
+ static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
+ static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");
+
+ // engine characteristics
+ static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
+ static _LIBCPP_CONSTEXPR const result_type increment = __c;
+ static _LIBCPP_CONSTEXPR const result_type modulus = __m;
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
+ static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
+
+ // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit linear_congruential_engine(result_type __s) { seed(__s); }
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit linear_congruential_engine(result_type __s = default_seed) {
+ seed(__s);
+ }
+#endif
+ template<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))>());}
+
+ // 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()();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const linear_congruential_engine& __x,
+ const linear_congruential_engine& __y)
+ {return __x.__x_ == __y.__x_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const linear_congruential_engine& __x,
+ const linear_congruential_engine& __y)
+ {return !(__x == __y);}
+
+private:
+
+ _LIBCPP_INLINE_VISIBILITY
+ void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
+ _LIBCPP_INLINE_VISIBILITY
+ void seed(true_type, false_type, result_type __s) {__x_ = __s;}
+ _LIBCPP_INLINE_VISIBILITY
+ void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
+ 1 : __s % __m;}
+ _LIBCPP_INLINE_VISIBILITY
+ void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
+
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+
+ template <class _CharT, class _Traits,
+ class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
+
+ template <class _CharT, class _Traits,
+ class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
+};
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+ linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+ linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+ linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+ _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+ linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+template<class _Sseq>
+void
+linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
+ integral_constant<unsigned, 1>)
+{
+ const unsigned __k = 1;
+ uint32_t __ar[__k+3];
+ __q.generate(__ar, __ar + __k + 3);
+ result_type __s = static_cast<result_type>(__ar[3] % __m);
+ __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+}
+
+template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+template<class _Sseq>
+void
+linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
+ integral_constant<unsigned, 2>)
+{
+ const unsigned __k = 2;
+ uint32_t __ar[__k+3];
+ __q.generate(__ar, __ar + __k + 3);
+ result_type __s = static_cast<result_type>((__ar[3] +
+ ((uint64_t)__ar[4] << 32)) % __m);
+ __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+}
+
+template <class _CharT, class _Traits,
+ class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+inline _LIBCPP_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>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ _UIntType __t;
+ __is >> __t;
+ if (!__is.fail())
+ __x.__x_ = __t;
+ return __is;
+}
+
+typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
+ minstd_rand0;
+typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
+ minstd_rand;
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_LINEAR_CONGRUENTIAL_ENGINE_H
diff --git a/libcxx/include/__random/log2.h b/libcxx/include/__random/log2.h
new file mode 100644
index 0000000000000..c2d9b6b69b272
--- /dev/null
+++ b/libcxx/include/__random/log2.h
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_LOG2_H
+#define _LIBCPP___RANDOM_LOG2_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <unsigned long long _Xp, size_t _Rp>
+struct __log2_imp
+{
+ static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
+ : __log2_imp<_Xp, _Rp - 1>::value;
+};
+
+template <unsigned long long _Xp>
+struct __log2_imp<_Xp, 0>
+{
+ static const size_t value = 0;
+};
+
+template <size_t _Rp>
+struct __log2_imp<0, _Rp>
+{
+ static const size_t value = _Rp + 1;
+};
+
+template <class _UIntType, _UIntType _Xp>
+struct __log2
+{
+ static const size_t value = __log2_imp<_Xp,
+ sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_LOG2_H
diff --git a/libcxx/include/__random/lognormal_distribution.h b/libcxx/include/__random/lognormal_distribution.h
new file mode 100644
index 0000000000000..752861c3de0cf
--- /dev/null
+++ b/libcxx/include/__random/lognormal_distribution.h
@@ -0,0 +1,163 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/normal_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS lognormal_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ normal_distribution<result_type> __nd_;
+ public:
+ typedef lognormal_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __m = 0, result_type __s = 1)
+ : __nd_(__m, __s) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type m() const {return __nd_.mean();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type s() const {return __nd_.stddev();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__nd_ == __y.__nd_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ friend class lognormal_distribution;
+
+ template <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);
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ lognormal_distribution() : lognormal_distribution(0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit lognormal_distribution(result_type __m, result_type __s = 1)
+ : __p_(param_type(__m, __s)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit lognormal_distribution(result_type __m = 0,
+ result_type __s = 1)
+ : __p_(param_type(__m, __s)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit lognormal_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {__p_.__nd_.reset();}
+
+ // generating functions
+ template<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 _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type m() const {return __p_.m();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type s() const {return __p_.s();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<result_type>::infinity();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const lognormal_distribution& __x,
+ const lognormal_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const lognormal_distribution& __x,
+ const lognormal_distribution& __y)
+ {return !(__x == __y);}
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const lognormal_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ lognormal_distribution<_RT>& __x);
+};
+
+template <class _CharT, class _Traits, class _RT>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const lognormal_distribution<_RT>& __x)
+{
+ return __os << __x.__p_.__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.__p_.__nd_;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/mersenne_twister_engine.h b/libcxx/include/__random/mersenne_twister_engine.h
new file mode 100644
index 0000000000000..121ffae37ec0d
--- /dev/null
+++ b/libcxx/include/__random/mersenne_twister_engine.h
@@ -0,0 +1,534 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H
+#define _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H
+
+#include <__algorithm/equal.h>
+#include <__algorithm/min.h>
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <limits>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
+
+template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+bool
+operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+
+template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+_LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+
+template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+
+template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
+{
+public:
+ // types
+ typedef _UIntType result_type;
+
+private:
+ result_type __x_[__n];
+ size_t __i_;
+
+ static_assert( 0 < __m, "mersenne_twister_engine invalid parameters");
+ static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
+ static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+ static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
+ static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters");
+ static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
+ static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
+ static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
+ static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
+ static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
+public:
+ static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+ static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
+ (result_type(1) << __w) - result_type(1);
+ static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
+ static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
+ static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
+ static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
+ static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
+ static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
+
+ // engine characteristics
+ static _LIBCPP_CONSTEXPR const size_t word_size = __w;
+ static _LIBCPP_CONSTEXPR const size_t state_size = __n;
+ static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
+ static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
+ static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
+ static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
+ static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
+ static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
+ static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
+ static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
+ static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
+ static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
+ static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+ static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
+
+ // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit mersenne_twister_engine(result_type __sd = default_seed) {
+ seed(__sd);
+ }
+#endif
+ template<class _Sseq>
+ _LIBCPP_INLINE_VISIBILITY
+ explicit mersenne_twister_engine(_Sseq& __q,
+ typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
+ {seed(__q);}
+ void seed(result_type __sd = default_seed);
+ template<class _Sseq>
+ _LIBCPP_INLINE_VISIBILITY
+ typename enable_if
+ <
+ __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
+ void
+ >::type
+ seed(_Sseq& __q)
+ {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
+
+ // generating functions
+ result_type operator()();
+ _LIBCPP_INLINE_VISIBILITY
+ void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+
+ template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+ friend
+ bool
+ operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+
+ template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+ friend
+ bool
+ operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+
+ template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+
+ template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+private:
+
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+
+ template <size_t __count>
+ _LIBCPP_INLINE_VISIBILITY
+ static
+ typename enable_if
+ <
+ __count < __w,
+ result_type
+ >::type
+ __lshift(result_type __x) {return (__x << __count) & _Max;}
+
+ template <size_t __count>
+ _LIBCPP_INLINE_VISIBILITY
+ static
+ typename enable_if
+ <
+ (__count >= __w),
+ result_type
+ >::type
+ __lshift(result_type) {return result_type(0);}
+
+ template <size_t __count>
+ _LIBCPP_INLINE_VISIBILITY
+ static
+ typename enable_if
+ <
+ __count < _Dt,
+ result_type
+ >::type
+ __rshift(result_type __x) {return __x >> __count;}
+
+ template <size_t __count>
+ _LIBCPP_INLINE_VISIBILITY
+ static
+ typename enable_if
+ <
+ (__count >= _Dt),
+ result_type
+ >::type
+ __rshift(result_type) {return result_type(0);}
+};
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const size_t
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+ _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+ mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+void
+mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
+ __t, __c, __l, __f>::seed(result_type __sd)
+ _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+{ // __w >= 2
+ __x_[0] = __sd & _Max;
+ for (size_t __i = 1; __i < __n; ++__i)
+ __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
+ __i_ = 0;
+}
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template<class _Sseq>
+void
+mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
+ __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
+{
+ const unsigned __k = 1;
+ uint32_t __ar[__n * __k];
+ __q.generate(__ar, __ar + __n * __k);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
+ const result_type __mask = __r == _Dt ? result_type(~0) :
+ (result_type(1) << __r) - result_type(1);
+ __i_ = 0;
+ if ((__x_[0] & ~__mask) == 0)
+ {
+ for (size_t __i = 1; __i < __n; ++__i)
+ if (__x_[__i] != 0)
+ return;
+ __x_[0] = result_type(1) << (__w - 1);
+ }
+}
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template<class _Sseq>
+void
+mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
+ __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
+{
+ const unsigned __k = 2;
+ uint32_t __ar[__n * __k];
+ __q.generate(__ar, __ar + __n * __k);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __x_[__i] = static_cast<result_type>(
+ (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
+ const result_type __mask = __r == _Dt ? result_type(~0) :
+ (result_type(1) << __r) - result_type(1);
+ __i_ = 0;
+ if ((__x_[0] & ~__mask) == 0)
+ {
+ for (size_t __i = 1; __i < __n; ++__i)
+ if (__x_[__i] != 0)
+ return;
+ __x_[0] = result_type(1) << (__w - 1);
+ }
+}
+
+template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
+ _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+ _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+_UIntType
+mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
+ __t, __c, __l, __f>::operator()()
+{
+ const size_t __j = (__i_ + 1) % __n;
+ const result_type __mask = __r == _Dt ? result_type(~0) :
+ (result_type(1) << __r) - result_type(1);
+ const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
+ const size_t __k = (__i_ + __m) % __n;
+ __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
+ result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
+ __i_ = __j;
+ __z ^= __lshift<__s>(__z) & __b;
+ __z ^= __lshift<__t>(__z) & __c;
+ return __z ^ __rshift<__l>(__z);
+}
+
+template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+bool
+operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
+{
+ if (__x.__i_ == __y.__i_)
+ return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
+ if (__x.__i_ == 0 || __y.__i_ == 0)
+ {
+ size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
+ if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
+ __y.__x_ + __y.__i_))
+ return false;
+ if (__x.__i_ == 0)
+ return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
+ return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
+ }
+ if (__x.__i_ < __y.__i_)
+ {
+ size_t __j = _Np - __y.__i_;
+ if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
+ __y.__x_ + __y.__i_))
+ return false;
+ if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
+ __y.__x_))
+ return false;
+ return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
+ __y.__x_ + (_Np - (__x.__i_ + __j)));
+ }
+ size_t __j = _Np - __x.__i_;
+ if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
+ __x.__x_ + __x.__i_))
+ return false;
+ if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
+ __x.__x_))
+ return false;
+ return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
+ __x.__x_ + (_Np - (__y.__i_ + __j)));
+}
+
+template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
+{
+ return !(__x == __y);
+}
+
+template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _Ostream;
+ __os.flags(_Ostream::dec | _Ostream::left);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.__x_[__x.__i_];
+ for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
+ __os << __sp << __x.__x_[__j];
+ for (size_t __j = 0; __j < __x.__i_; ++__j)
+ __os << __sp << __x.__x_[__j];
+ return __os;
+}
+
+template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
+ _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
+ _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
+ _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ _UInt __t[_Np];
+ for (size_t __i = 0; __i < _Np; ++__i)
+ __is >> __t[__i];
+ if (!__is.fail())
+ {
+ for (size_t __i = 0; __i < _Np; ++__i)
+ __x.__x_[__i] = __t[__i];
+ __x.__i_ = 0;
+ }
+ return __is;
+}
+
+typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
+ 0x9908b0df, 11, 0xffffffff,
+ 7, 0x9d2c5680,
+ 15, 0xefc60000,
+ 18, 1812433253> mt19937;
+typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
+ 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
+ 17, 0x71d67fffeda60000ULL,
+ 37, 0xfff7eee000000000ULL,
+ 43, 6364136223846793005ULL> mt19937_64;
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H
diff --git a/libcxx/include/__random/negative_binomial_distribution.h b/libcxx/include/__random/negative_binomial_distribution.h
new file mode 100644
index 0000000000000..7329bac2ff857
--- /dev/null
+++ b/libcxx/include/__random/negative_binomial_distribution.h
@@ -0,0 +1,176 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/bernoulli_distribution.h>
+#include <__random/gamma_distribution.h>
+#include <__random/poisson_distribution.h>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
+{
+public:
+ // types
+ typedef _IntType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __k_;
+ double __p_;
+ public:
+ typedef negative_binomial_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __k = 1, double __p = 0.5)
+ : __k_(__k), __p_(__p) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type k() const {return __k_;}
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ negative_binomial_distribution() : negative_binomial_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
+ : __p_(__k, __p) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit negative_binomial_distribution(result_type __k = 1,
+ double __p = 0.5)
+ : __p_(__k, __p) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type k() const {return __p_.k();}
+ _LIBCPP_INLINE_VISIBILITY
+ double p() const {return __p_.p();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _IntType>
+template<class _URNG>
+_IntType
+negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
+{
+ result_type __k = __pr.k();
+ double __p = __pr.p();
+ if (__k <= 21 * __p)
+ {
+ bernoulli_distribution __gen(__p);
+ result_type __f = 0;
+ result_type __s = 0;
+ while (__s < __k)
+ {
+ if (__gen(__urng))
+ ++__s;
+ else
+ ++__f;
+ }
+ return __f;
+ }
+ return poisson_distribution<result_type>(gamma_distribution<double>
+ (__k, (1-__p)/__p)(__urng))(__urng);
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const negative_binomial_distribution<_IntType>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ return __os << __x.k() << __sp << __x.p();
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ negative_binomial_distribution<_IntType>& __x)
+{
+ typedef negative_binomial_distribution<_IntType> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __k;
+ double __p;
+ __is >> __k >> __p;
+ if (!__is.fail())
+ __x.param(param_type(__k, __p));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/normal_distribution.h b/libcxx/include/__random/normal_distribution.h
new file mode 100644
index 0000000000000..b460ffb7ea9d7
--- /dev/null
+++ b/libcxx/include/__random/normal_distribution.h
@@ -0,0 +1,208 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS normal_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __mean_;
+ result_type __stddev_;
+ public:
+ typedef normal_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __mean = 0, result_type __stddev = 1)
+ : __mean_(__mean), __stddev_(__stddev) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type mean() const {return __mean_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type stddev() const {return __stddev_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+ result_type _V_;
+ bool _V_hot_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ normal_distribution() : normal_distribution(0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit normal_distribution(result_type __mean, result_type __stddev = 1)
+ : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit normal_distribution(result_type __mean = 0,
+ result_type __stddev = 1)
+ : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit normal_distribution(const param_type& __p)
+ : __p_(__p), _V_hot_(false) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {_V_hot_ = false;}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type mean() const {return __p_.mean();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type stddev() const {return __p_.stddev();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return -numeric_limits<result_type>::infinity();}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const normal_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ normal_distribution<_RT>& __x);
+};
+
+template <class _RealType>
+template<class _URNG>
+_RealType
+normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ 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 _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const normal_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
+ if (__x._V_hot_)
+ __os << __sp << __x._V_;
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ normal_distribution<_RT>& __x)
+{
+ typedef normal_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __mean;
+ result_type __stddev;
+ result_type _Vp = 0;
+ bool _V_hot = false;
+ __is >> __mean >> __stddev >> _V_hot;
+ if (_V_hot)
+ __is >> _Vp;
+ if (!__is.fail())
+ {
+ __x.param(param_type(__mean, __stddev));
+ __x._V_hot_ = _V_hot;
+ __x._V_ = _Vp;
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/piecewise_constant_distribution.h b/libcxx/include/__random/piecewise_constant_distribution.h
new file mode 100644
index 0000000000000..ece20d1a1d6e7
--- /dev/null
+++ b/libcxx/include/__random/piecewise_constant_distribution.h
@@ -0,0 +1,356 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
+
+#include <__algorithm/upper_bound.h>
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <iosfwd>
+#include <numeric>
+#include <vector>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ vector<result_type> __b_;
+ vector<result_type> __densities_;
+ vector<result_type> __areas_;
+ public:
+ typedef piecewise_constant_distribution distribution_type;
+
+ param_type();
+ template<class _InputIteratorB, class _InputIteratorW>
+ param_type(_InputIteratorB __fB, _InputIteratorB __lB,
+ _InputIteratorW __fW);
+#ifndef _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
+#endif // _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ param_type(size_t __nw, result_type __xmin, result_type __xmax,
+ _UnaryOperation __fw);
+ param_type(param_type const&) = default;
+ param_type & operator=(const param_type& __rhs);
+
+ _LIBCPP_INLINE_VISIBILITY
+ vector<result_type> intervals() const {return __b_;}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+
+ private:
+ void __init();
+
+ friend class piecewise_constant_distribution;
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_constant_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_constant_distribution<_RT>& __x);
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+ _LIBCPP_INLINE_VISIBILITY
+ piecewise_constant_distribution() {}
+ template<class _InputIteratorB, class _InputIteratorW>
+ _LIBCPP_INLINE_VISIBILITY
+ piecewise_constant_distribution(_InputIteratorB __fB,
+ _InputIteratorB __lB,
+ _InputIteratorW __fW)
+ : __p_(__fB, __lB, __fW) {}
+
+#ifndef _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ _LIBCPP_INLINE_VISIBILITY
+ 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) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit piecewise_constant_distribution(const param_type& __p)
+ : __p_(__p) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> 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();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return __p_.__b_.front();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return __p_.__b_.back();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const piecewise_constant_distribution& __x,
+ const piecewise_constant_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const piecewise_constant_distribution& __x,
+ const piecewise_constant_distribution& __y)
+ {return !(__x == __y);}
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_constant_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_constant_distribution<_RT>& __x);
+};
+
+template<class _RealType>
+typename piecewise_constant_distribution<_RealType>::param_type &
+piecewise_constant_distribution<_RealType>::param_type::operator=
+ (const param_type& __rhs)
+{
+// These can throw
+ __b_.reserve (__rhs.__b_.size ());
+ __densities_.reserve(__rhs.__densities_.size());
+ __areas_.reserve (__rhs.__areas_.size());
+
+// These can not throw
+ __b_ = __rhs.__b_;
+ __densities_ = __rhs.__densities_;
+ __areas_ = __rhs.__areas_;
+ return *this;
+}
+
+template<class _RealType>
+void
+piecewise_constant_distribution<_RealType>::param_type::__init()
+{
+ // __densities_ contains non-normalized areas
+ result_type __total_area = _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>
+piecewise_constant_distribution<_RealType>::param_type::param_type()
+ : __b_(2),
+ __densities_(1, 1.0),
+ __areas_(1, 0.0)
+{
+ __b_[1] = 1;
+}
+
+template<class _RealType>
+template<class _InputIteratorB, class _InputIteratorW>
+piecewise_constant_distribution<_RealType>::param_type::param_type(
+ _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
+ : __b_(__fB, __lB)
+{
+ if (__b_.size() < 2)
+ {
+ __b_.resize(2);
+ __b_[0] = 0;
+ __b_[1] = 1;
+ __densities_.assign(1, 1.0);
+ __areas_.assign(1, 0.0);
+ }
+ else
+ {
+ __densities_.reserve(__b_.size() - 1);
+ for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
+ __densities_.push_back(*__fW);
+ __init();
+ }
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template<class _RealType>
+template<class _UnaryOperation>
+piecewise_constant_distribution<_RealType>::param_type::param_type(
+ initializer_list<result_type> __bl, _UnaryOperation __fw)
+ : __b_(__bl.begin(), __bl.end())
+{
+ if (__b_.size() < 2)
+ {
+ __b_.resize(2);
+ __b_[0] = 0;
+ __b_[1] = 1;
+ __densities_.assign(1, 1.0);
+ __areas_.assign(1, 0.0);
+ }
+ else
+ {
+ __densities_.reserve(__b_.size() - 1);
+ for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
+ __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
+ __init();
+ }
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template<class _RealType>
+template<class _UnaryOperation>
+piecewise_constant_distribution<_RealType>::param_type::param_type(
+ size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+ : __b_(__nw == 0 ? 2 : __nw + 1)
+{
+ size_t __n = __b_.size() - 1;
+ result_type __d = (__xmax - __xmin) / __n;
+ __densities_.reserve(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ {
+ __b_[__i] = __xmin + __i * __d;
+ __densities_.push_back(__fw(__b_[__i] + __d*.5));
+ }
+ __b_[__n] = __xmax;
+ __init();
+}
+
+template<class _RealType>
+template<class _URNG>
+_RealType
+piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ typedef uniform_real_distribution<result_type> _Gen;
+ result_type __u = _Gen()(__g);
+ ptr
diff _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 _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_constant_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ size_t __n = __x.__p_.__b_.size();
+ __os << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__b_[__i];
+ __n = __x.__p_.__densities_.size();
+ __os << __sp << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__densities_[__i];
+ __n = __x.__p_.__areas_.size();
+ __os << __sp << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__areas_[__i];
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_constant_distribution<_RT>& __x)
+{
+ typedef piecewise_constant_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ size_t __n;
+ __is >> __n;
+ vector<result_type> __b(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __b[__i];
+ __is >> __n;
+ vector<result_type> __densities(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __densities[__i];
+ __is >> __n;
+ vector<result_type> __areas(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __areas[__i];
+ if (!__is.fail())
+ {
+ swap(__x.__p_.__b_, __b);
+ swap(__x.__p_.__densities_, __densities);
+ swap(__x.__p_.__areas_, __areas);
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
diff --git a/libcxx/include/__random/piecewise_linear_distribution.h b/libcxx/include/__random/piecewise_linear_distribution.h
new file mode 100644
index 0000000000000..b2ba164d07070
--- /dev/null
+++ b/libcxx/include/__random/piecewise_linear_distribution.h
@@ -0,0 +1,372 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
+
+#include <__algorithm/upper_bound.h>
+#include <__config>
+#include <__random/uniform_real_distribution.h>
+#include <iosfwd>
+#include <numeric>
+#include <vector>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ vector<result_type> __b_;
+ vector<result_type> __densities_;
+ vector<result_type> __areas_;
+ public:
+ typedef piecewise_linear_distribution distribution_type;
+
+ param_type();
+ template<class _InputIteratorB, class _InputIteratorW>
+ param_type(_InputIteratorB __fB, _InputIteratorB __lB,
+ _InputIteratorW __fW);
+#ifndef _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
+#endif // _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ param_type(size_t __nw, result_type __xmin, result_type __xmax,
+ _UnaryOperation __fw);
+ param_type(param_type const&) = default;
+ param_type & operator=(const param_type& __rhs);
+
+ _LIBCPP_INLINE_VISIBILITY
+ vector<result_type> intervals() const {return __b_;}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+
+ private:
+ void __init();
+
+ friend class piecewise_linear_distribution;
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_linear_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_linear_distribution<_RT>& __x);
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+ _LIBCPP_INLINE_VISIBILITY
+ piecewise_linear_distribution() {}
+ template<class _InputIteratorB, class _InputIteratorW>
+ _LIBCPP_INLINE_VISIBILITY
+ piecewise_linear_distribution(_InputIteratorB __fB,
+ _InputIteratorB __lB,
+ _InputIteratorW __fW)
+ : __p_(__fB, __lB, __fW) {}
+
+#ifndef _LIBCPP_CXX03_LANG
+ template<class _UnaryOperation>
+ _LIBCPP_INLINE_VISIBILITY
+ 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) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit piecewise_linear_distribution(const param_type& __p)
+ : __p_(__p) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> 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();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return __p_.__b_.front();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return __p_.__b_.back();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const piecewise_linear_distribution& __x,
+ const piecewise_linear_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const piecewise_linear_distribution& __x,
+ const piecewise_linear_distribution& __y)
+ {return !(__x == __y);}
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_linear_distribution<_RT>& __x);
+
+ template <class _CharT, class _Traits, class _RT>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_linear_distribution<_RT>& __x);
+};
+
+template<class _RealType>
+typename piecewise_linear_distribution<_RealType>::param_type &
+piecewise_linear_distribution<_RealType>::param_type::operator=
+ (const param_type& __rhs)
+{
+// These can throw
+ __b_.reserve (__rhs.__b_.size ());
+ __densities_.reserve(__rhs.__densities_.size());
+ __areas_.reserve (__rhs.__areas_.size());
+
+// These can not throw
+ __b_ = __rhs.__b_;
+ __densities_ = __rhs.__densities_;
+ __areas_ = __rhs.__areas_;
+ return *this;
+}
+
+
+template<class _RealType>
+void
+piecewise_linear_distribution<_RealType>::param_type::__init()
+{
+ __areas_.assign(__densities_.size() - 1, result_type());
+ result_type _Sp = 0;
+ for (size_t __i = 0; __i < __areas_.size(); ++__i)
+ {
+ __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
+ (__b_[__i+1] - __b_[__i]) * .5;
+ _Sp += __areas_[__i];
+ }
+ for (size_t __i = __areas_.size(); __i > 1;)
+ {
+ --__i;
+ __areas_[__i] = __areas_[__i-1] / _Sp;
+ }
+ __areas_[0] = 0;
+ for (size_t __i = 1; __i < __areas_.size(); ++__i)
+ __areas_[__i] += __areas_[__i-1];
+ for (size_t __i = 0; __i < __densities_.size(); ++__i)
+ __densities_[__i] /= _Sp;
+}
+
+template<class _RealType>
+piecewise_linear_distribution<_RealType>::param_type::param_type()
+ : __b_(2),
+ __densities_(2, 1.0),
+ __areas_(1, 0.0)
+{
+ __b_[1] = 1;
+}
+
+template<class _RealType>
+template<class _InputIteratorB, class _InputIteratorW>
+piecewise_linear_distribution<_RealType>::param_type::param_type(
+ _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
+ : __b_(__fB, __lB)
+{
+ if (__b_.size() < 2)
+ {
+ __b_.resize(2);
+ __b_[0] = 0;
+ __b_[1] = 1;
+ __densities_.assign(2, 1.0);
+ __areas_.assign(1, 0.0);
+ }
+ else
+ {
+ __densities_.reserve(__b_.size());
+ for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
+ __densities_.push_back(*__fW);
+ __init();
+ }
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template<class _RealType>
+template<class _UnaryOperation>
+piecewise_linear_distribution<_RealType>::param_type::param_type(
+ initializer_list<result_type> __bl, _UnaryOperation __fw)
+ : __b_(__bl.begin(), __bl.end())
+{
+ if (__b_.size() < 2)
+ {
+ __b_.resize(2);
+ __b_[0] = 0;
+ __b_[1] = 1;
+ __densities_.assign(2, 1.0);
+ __areas_.assign(1, 0.0);
+ }
+ else
+ {
+ __densities_.reserve(__b_.size());
+ for (size_t __i = 0; __i < __b_.size(); ++__i)
+ __densities_.push_back(__fw(__b_[__i]));
+ __init();
+ }
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template<class _RealType>
+template<class _UnaryOperation>
+piecewise_linear_distribution<_RealType>::param_type::param_type(
+ size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+ : __b_(__nw == 0 ? 2 : __nw + 1)
+{
+ size_t __n = __b_.size() - 1;
+ result_type __d = (__xmax - __xmin) / __n;
+ __densities_.reserve(__b_.size());
+ for (size_t __i = 0; __i < __n; ++__i)
+ {
+ __b_[__i] = __xmin + __i * __d;
+ __densities_.push_back(__fw(__b_[__i]));
+ }
+ __b_[__n] = __xmax;
+ __densities_.push_back(__fw(__b_[__n]));
+ __init();
+}
+
+template<class _RealType>
+template<class _URNG>
+_RealType
+piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ typedef uniform_real_distribution<result_type> _Gen;
+ result_type __u = _Gen()(__g);
+ ptr
diff _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 _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const piecewise_linear_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ size_t __n = __x.__p_.__b_.size();
+ __os << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__b_[__i];
+ __n = __x.__p_.__densities_.size();
+ __os << __sp << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__densities_[__i];
+ __n = __x.__p_.__areas_.size();
+ __os << __sp << __n;
+ for (size_t __i = 0; __i < __n; ++__i)
+ __os << __sp << __x.__p_.__areas_[__i];
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ piecewise_linear_distribution<_RT>& __x)
+{
+ typedef piecewise_linear_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ size_t __n;
+ __is >> __n;
+ vector<result_type> __b(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __b[__i];
+ __is >> __n;
+ vector<result_type> __densities(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __densities[__i];
+ __is >> __n;
+ vector<result_type> __areas(__n);
+ for (size_t __i = 0; __i < __n; ++__i)
+ __is >> __areas[__i];
+ if (!__is.fail())
+ {
+ swap(__x.__p_.__b_, __b);
+ swap(__x.__p_.__densities_, __densities);
+ swap(__x.__p_.__areas_, __areas);
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
diff --git a/libcxx/include/__random/poisson_distribution.h b/libcxx/include/__random/poisson_distribution.h
new file mode 100644
index 0000000000000..fb213b0103ada
--- /dev/null
+++ b/libcxx/include/__random/poisson_distribution.h
@@ -0,0 +1,276 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/exponential_distribution.h>
+#include <__random/normal_distribution.h>
+#include <__random/uniform_real_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS poisson_distribution
+{
+public:
+ // types
+ typedef _IntType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ double __mean_;
+ double __s_;
+ double __d_;
+ double __l_;
+ double __omega_;
+ double __c0_;
+ double __c1_;
+ double __c2_;
+ double __c3_;
+ double __c_;
+
+ public:
+ typedef poisson_distribution distribution_type;
+
+ explicit param_type(double __mean = 1.0);
+
+ _LIBCPP_INLINE_VISIBILITY
+ double mean() const {return __mean_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__mean_ == __y.__mean_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+
+ friend class poisson_distribution;
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ poisson_distribution() : poisson_distribution(1.0) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit poisson_distribution(double __mean)
+ : __p_(__mean) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit poisson_distribution(double __mean = 1.0)
+ : __p_(__mean) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ double mean() const {return __p_.mean();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+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_;
+ }
+}
+
+template <class _IntType>
+template<class _URNG>
+_IntType
+poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
+{
+ 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 = _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;
+ }
+ }
+ }
+ return _VSTD::__clamp_to_integral<result_type>(__tx);
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const poisson_distribution<_IntType>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ return __os << __x.mean();
+}
+
+template <class _CharT, class _Traits, class _IntType>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ poisson_distribution<_IntType>& __x)
+{
+ typedef poisson_distribution<_IntType> _Eng;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ double __mean;
+ __is >> __mean;
+ if (!__is.fail())
+ __x.param(param_type(__mean));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
diff --git a/libcxx/include/__random/random_device.h b/libcxx/include/__random/random_device.h
new file mode 100644
index 0000000000000..f62f7a3d269bb
--- /dev/null
+++ b/libcxx/include/__random/random_device.h
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_RANDOM_DEVICE_H
+#define _LIBCPP___RANDOM_RANDOM_DEVICE_H
+
+#include <__config>
+#include <string>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE)
+
+class _LIBCPP_TYPE_VIS random_device
+{
+#ifdef _LIBCPP_USING_DEV_RANDOM
+ int __f_;
+#endif // defined(_LIBCPP_USING_DEV_RANDOM)
+public:
+ // types
+ typedef unsigned result_type;
+
+ // generator characteristics
+ static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+ static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
+
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
+
+ // constructors
+#ifndef _LIBCPP_CXX03_LANG
+ random_device() : random_device("/dev/urandom") {}
+ explicit random_device(const string& __token);
+#else
+ explicit random_device(const string& __token = "/dev/urandom");
+#endif
+ ~random_device();
+
+ // generating functions
+ result_type operator()();
+
+ // property functions
+ double entropy() const _NOEXCEPT;
+
+private:
+ // no copy functions
+ random_device(const random_device&); // = delete;
+ random_device& operator=(const random_device&); // = delete;
+};
+
+#endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_RANDOM_DEVICE_H
diff --git a/libcxx/include/__random/ranlux.h b/libcxx/include/__random/ranlux.h
new file mode 100644
index 0000000000000..0b415928df4d6
--- /dev/null
+++ b/libcxx/include/__random/ranlux.h
@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_RANLUX_H
+#define _LIBCPP___RANDOM_RANLUX_H
+
+#include <__config>
+#include <__random/discard_block_engine.h>
+#include <__random/subtract_with_carry_engine.h>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
+typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
+
+typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
+typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANDOM_RANLUX_H
diff --git a/libcxx/include/__random/seed_seq.h b/libcxx/include/__random/seed_seq.h
new file mode 100644
index 0000000000000..97bc88d0d4d15
--- /dev/null
+++ b/libcxx/include/__random/seed_seq.h
@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_SEED_SEQ_H
+#define _LIBCPP___RANDOM_SEED_SEQ_H
+
+#include <__algorithm/copy.h>
+#include <__algorithm/fill.h>
+#include <__algorithm/max.h>
+#include <__config>
+#include <initializer_list>
+#include <vector>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_TEMPLATE_VIS seed_seq
+{
+public:
+ // types
+ typedef uint32_t result_type;
+
+private:
+ vector<result_type> __v_;
+
+ template<class _InputIterator>
+ void init(_InputIterator __first, _InputIterator __last);
+public:
+ // constructors
+ _LIBCPP_INLINE_VISIBILITY
+ seed_seq() _NOEXCEPT {}
+#ifndef _LIBCPP_CXX03_LANG
+ template<class _Tp>
+ _LIBCPP_INLINE_VISIBILITY
+ 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)
+ {init(__first, __last);}
+
+ // generating functions
+ template<class _RandomAccessIterator>
+ 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);}
+
+private:
+ // no copy functions
+ seed_seq(const seed_seq&); // = delete;
+ void operator=(const seed_seq&); // = delete;
+
+ _LIBCPP_INLINE_VISIBILITY
+ static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
+};
+
+template<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)
+ {
+ _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;
+ }
+ for (size_t __k = 1; __k <= __s; ++__k)
+ {
+ const size_t __kmodn = __k % __n;
+ const size_t __kpmodn = (__k + __p) % __n;
+ result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
+ ^ __first[(__k - 1) % __n]);
+ __first[__kpmodn] += __r;
+ __r += __kmodn + __v_[__k-1];
+ __first[(__k + __q) % __n] += __r;
+ __first[__kmodn] = __r;
+ }
+ for (size_t __k = __s + 1; __k < __m; ++__k)
+ {
+ const size_t __kmodn = __k % __n;
+ const size_t __kpmodn = (__k + __p) % __n;
+ result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
+ ^ __first[(__k - 1) % __n]);
+ __first[__kpmodn] += __r;
+ __r += __kmodn;
+ __first[(__k + __q) % __n] += __r;
+ __first[__kmodn] = __r;
+ }
+ for (size_t __k = __m; __k < __m + __n; ++__k)
+ {
+ const size_t __kmodn = __k % __n;
+ const size_t __kpmodn = (__k + __p) % __n;
+ result_type __r = 1566083941 * _Tp(__first[__kmodn] +
+ __first[__kpmodn] +
+ __first[(__k - 1) % __n]);
+ __first[__kpmodn] ^= __r;
+ __r -= __kmodn;
+ __first[(__k + __q) % __n] ^= __r;
+ __first[__kmodn] = __r;
+ }
+ }
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_SEED_SEQ_H
diff --git a/libcxx/include/__random/shuffle_order_engine.h b/libcxx/include/__random/shuffle_order_engine.h
new file mode 100644
index 0000000000000..7a5735dd79337
--- /dev/null
+++ b/libcxx/include/__random/shuffle_order_engine.h
@@ -0,0 +1,283 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H
+#define _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H
+
+#include <__algorithm/equal.h>
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <__utility/move.h>
+#include <cstdint>
+#include <iosfwd>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <uint64_t _Xp, uint64_t _Yp>
+struct __ugcd
+{
+ static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
+};
+
+template <uint64_t _Xp>
+struct __ugcd<_Xp, 0>
+{
+ static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
+};
+
+template <uint64_t _Np, uint64_t _Dp>
+class __uratio
+{
+ static_assert(_Dp != 0, "__uratio divide by 0");
+ static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
+public:
+ static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
+ static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
+
+ typedef __uratio<num, den> type;
+};
+
+template<class _Engine, size_t __k>
+class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
+{
+ static_assert(0 < __k, "shuffle_order_engine invalid parameters");
+public:
+ // types
+ typedef typename _Engine::result_type result_type;
+
+private:
+ _Engine __e_;
+ result_type _V_[__k];
+ result_type _Y_;
+
+public:
+ // engine characteristics
+ static _LIBCPP_CONSTEXPR const size_t table_size = __k;
+
+#ifdef _LIBCPP_CXX03_LANG
+ static const result_type _Min = _Engine::_Min;
+ static const result_type _Max = _Engine::_Max;
+#else
+ static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
+ static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
+#endif
+ static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+
+ static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
+
+ // constructors and seeding functions
+ _LIBCPP_INLINE_VISIBILITY
+ shuffle_order_engine() {__init();}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit shuffle_order_engine(const _Engine& __e)
+ : __e_(__e) {__init();}
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit shuffle_order_engine(_Engine&& __e)
+ : __e_(_VSTD::move(__e)) {__init();}
+#endif // _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
+ template<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();}
+
+ // 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()();}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ const _Engine& base() const _NOEXCEPT {return __e_;}
+
+private:
+ template<class _Eng, size_t _Kp>
+ friend
+ bool
+ operator==(
+ const shuffle_order_engine<_Eng, _Kp>& __x,
+ const shuffle_order_engine<_Eng, _Kp>& __y);
+
+ template<class _Eng, size_t _Kp>
+ friend
+ bool
+ operator!=(
+ const shuffle_order_engine<_Eng, _Kp>& __x,
+ const shuffle_order_engine<_Eng, _Kp>& __y);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Kp>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const shuffle_order_engine<_Eng, _Kp>& __x);
+
+ template <class _CharT, class _Traits,
+ class _Eng, size_t _Kp>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ shuffle_order_engine<_Eng, _Kp>& __x);
+
+ _LIBCPP_INLINE_VISIBILITY
+ void __init()
+ {
+ for (size_t __i = 0; __i < __k; ++__i)
+ _V_[__i] = __e_();
+ _Y_ = __e_();
+ }
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type __eval2(true_type) {return __evalf<__k, 0>();}
+
+ template <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>
+ _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 __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<class _Engine, size_t __k>
+ _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
+
+template<class _Eng, size_t _Kp>
+bool
+operator==(
+ const shuffle_order_engine<_Eng, _Kp>& __x,
+ const shuffle_order_engine<_Eng, _Kp>& __y)
+{
+ return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
+ __x.__e_ == __y.__e_;
+}
+
+template<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 _CharT, class _Traits,
+ class _Eng, size_t _Kp>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const shuffle_order_engine<_Eng, _Kp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _Ostream;
+ __os.flags(_Ostream::dec | _Ostream::left);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.__e_ << __sp << __x._V_[0];
+ for (size_t __i = 1; __i < _Kp; ++__i)
+ __os << __sp << __x._V_[__i];
+ return __os << __sp << __x._Y_;
+}
+
+template <class _CharT, class _Traits,
+ class _Eng, size_t _Kp>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ shuffle_order_engine<_Eng, _Kp>& __x)
+{
+ typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ _Eng __e;
+ result_type _Vp[_Kp+1];
+ __is >> __e;
+ for (size_t __i = 0; __i < _Kp+1; ++__i)
+ __is >> _Vp[__i];
+ if (!__is.fail())
+ {
+ __x.__e_ = __e;
+ for (size_t __i = 0; __i < _Kp; ++__i)
+ __x._V_[__i] = _Vp[__i];
+ __x._Y_ = _Vp[_Kp];
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_SHUFFLE_ORDER_ENGINE_H
diff --git a/libcxx/include/__random/student_t_distribution.h b/libcxx/include/__random/student_t_distribution.h
new file mode 100644
index 0000000000000..0cf911e4cd767
--- /dev/null
+++ b/libcxx/include/__random/student_t_distribution.h
@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/gamma_distribution.h>
+#include <__random/normal_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS student_t_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __n_;
+ public:
+ typedef student_t_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __n = 1) : __n_(__n) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __n_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__n_ == __y.__n_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+ normal_distribution<result_type> __nd_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ student_t_distribution() : student_t_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit student_t_distribution(result_type __n)
+ : __p_(param_type(__n)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit student_t_distribution(result_type __n = 1)
+ : __p_(param_type(__n)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit student_t_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {__nd_.reset();}
+
+ // generating functions
+ template<class _URNG>
+ _LIBCPP_INLINE_VISIBILITY
+ result_type operator()(_URNG& __g)
+ {return (*this)(__g, __p_);}
+ template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type n() const {return __p_.n();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return -numeric_limits<result_type>::infinity();}
+ _LIBCPP_INLINE_VISIBILITY
+ 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);}
+};
+
+template <class _RealType>
+template<class _URNG>
+_RealType
+student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ gamma_distribution<result_type> __gd(__p.n() * .5, 2);
+ return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const student_t_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ __os << __x.n();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ student_t_distribution<_RT>& __x)
+{
+ typedef student_t_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __n;
+ __is >> __n;
+ if (!__is.fail())
+ __x.param(param_type(__n));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
diff --git a/libcxx/include/__random/subtract_with_carry_engine.h b/libcxx/include/__random/subtract_with_carry_engine.h
new file mode 100644
index 0000000000000..073f84dccff60
--- /dev/null
+++ b/libcxx/include/__random/subtract_with_carry_engine.h
@@ -0,0 +1,352 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H
+#define _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H
+
+#include <__algorithm/equal.h>
+#include <__algorithm/min.h>
+#include <__config>
+#include <__random/is_seed_sequence.h>
+#include <__random/linear_congruential_engine.h>
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <limits>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
+
+template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+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 _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+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>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
+{
+public:
+ // types
+ typedef _UIntType result_type;
+
+private:
+ result_type __x_[__r];
+ result_type __c_;
+ size_t __i_;
+
+ static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+ static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters");
+ static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
+ static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters");
+ static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
+public:
+ static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+ static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
+ (result_type(1) << __w) - result_type(1);
+ static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
+
+ // engine characteristics
+ static _LIBCPP_CONSTEXPR const size_t word_size = __w;
+ static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
+ static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+ _LIBCPP_INLINE_VISIBILITY
+ static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+ static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
+
+ // constructors and seeding functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit subtract_with_carry_engine(result_type __sd = default_seed) {
+ seed(__sd);
+ }
+#endif
+ template<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>());}
+
+ // generating functions
+ result_type operator()();
+ _LIBCPP_INLINE_VISIBILITY
+ void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+
+ template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+ friend
+ bool
+ operator==(
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+
+ template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+ friend
+ bool
+ operator!=(
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+
+ template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+ friend
+ basic_ostream<_CharT, _Traits>&
+ operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+
+ template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+ friend
+ basic_istream<_CharT, _Traits>&
+ operator>>(basic_istream<_CharT, _Traits>& __is,
+ subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+
+private:
+
+ void seed(result_type __sd, integral_constant<unsigned, 1>);
+ void seed(result_type __sd, integral_constant<unsigned, 2>);
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+ template<class _Sseq>
+ void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+};
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+ _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+ _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+ _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+ _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
+ subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+void
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
+ integral_constant<unsigned, 1>)
+{
+ linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
+ __e(__sd == 0u ? default_seed : __sd);
+ for (size_t __i = 0; __i < __r; ++__i)
+ __x_[__i] = static_cast<result_type>(__e() & _Max);
+ __c_ = __x_[__r-1] == 0;
+ __i_ = 0;
+}
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+void
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
+ integral_constant<unsigned, 2>)
+{
+ linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
+ __e(__sd == 0u ? default_seed : __sd);
+ for (size_t __i = 0; __i < __r; ++__i)
+ {
+ result_type __e0 = __e();
+ __x_[__i] = static_cast<result_type>(
+ (__e0 + ((uint64_t)__e() << 32)) & _Max);
+ }
+ __c_ = __x_[__r-1] == 0;
+ __i_ = 0;
+}
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+template<class _Sseq>
+void
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
+ integral_constant<unsigned, 1>)
+{
+ const unsigned __k = 1;
+ uint32_t __ar[__r * __k];
+ __q.generate(__ar, __ar + __r * __k);
+ for (size_t __i = 0; __i < __r; ++__i)
+ __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
+ __c_ = __x_[__r-1] == 0;
+ __i_ = 0;
+}
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+template<class _Sseq>
+void
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
+ integral_constant<unsigned, 2>)
+{
+ const unsigned __k = 2;
+ uint32_t __ar[__r * __k];
+ __q.generate(__ar, __ar + __r * __k);
+ for (size_t __i = 0; __i < __r; ++__i)
+ __x_[__i] = static_cast<result_type>(
+ (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
+ __c_ = __x_[__r-1] == 0;
+ __i_ = 0;
+}
+
+template<class _UIntType, size_t __w, size_t __s, size_t __r>
+_UIntType
+subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
+{
+ const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
+ result_type& __xr = __x_[__i_];
+ result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
+ __xr = (__xs - __xr - __c_) & _Max;
+ __c_ = __new_c;
+ __i_ = (__i_ + 1) % __r;
+ return __xr;
+}
+
+template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+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>
+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 _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _Ostream;
+ __os.flags(_Ostream::dec | _Ostream::left);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.__x_[__x.__i_];
+ for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
+ __os << __sp << __x.__x_[__j];
+ for (size_t __j = 0; __j < __x.__i_; ++__j)
+ __os << __sp << __x.__x_[__j];
+ __os << __sp << __x.__c_;
+ return __os;
+}
+
+template <class _CharT, class _Traits,
+ class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ _UInt __t[_Rp+1];
+ for (size_t __i = 0; __i < _Rp+1; ++__i)
+ __is >> __t[__i];
+ if (!__is.fail())
+ {
+ for (size_t __i = 0; __i < _Rp; ++__i)
+ __x.__x_[__i] = __t[__i];
+ __x.__c_ = __t[_Rp];
+ __x.__i_ = 0;
+ }
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_SUBTRACT_WITH_CARRY_ENGINE_H
diff --git a/libcxx/include/__random/uniform_int_distribution.h b/libcxx/include/__random/uniform_int_distribution.h
index a7cfa1ec73054..3f47d5f4707dc 100644
--- a/libcxx/include/__random/uniform_int_distribution.h
+++ b/libcxx/include/__random/uniform_int_distribution.h
@@ -11,6 +11,7 @@
#include <__bits>
#include <__config>
+#include <__random/log2.h>
#include <cstddef>
#include <cstdint>
#include <iosfwd>
@@ -26,34 +27,6 @@ _LIBCPP_PUSH_MACROS
_LIBCPP_BEGIN_NAMESPACE_STD
-// __independent_bits_engine
-
-template <unsigned long long _Xp, size_t _Rp>
-struct __log2_imp
-{
- static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
- : __log2_imp<_Xp, _Rp - 1>::value;
-};
-
-template <unsigned long long _Xp>
-struct __log2_imp<_Xp, 0>
-{
- static const size_t value = 0;
-};
-
-template <size_t _Rp>
-struct __log2_imp<0, _Rp>
-{
- static const size_t value = _Rp + 1;
-};
-
-template <class _UIntType, _UIntType _Xp>
-struct __log2
-{
- static const size_t value = __log2_imp<_Xp,
- sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
-};
-
template<class _Engine, class _UIntType>
class __independent_bits_engine
{
diff --git a/libcxx/include/__random/uniform_random_bit_generator.h b/libcxx/include/__random/uniform_random_bit_generator.h
new file mode 100644
index 0000000000000..7b2f0df868d7b
--- /dev/null
+++ b/libcxx/include/__random/uniform_random_bit_generator.h
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
+#define _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
+
+#include <__concepts/arithmetic.h>
+#include <__concepts/invocable.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+// [rand.req.urng]
+template<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 > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_UNIFORM_RANDOM_BIT_GENERATOR_H
diff --git a/libcxx/include/__random/uniform_real_distribution.h b/libcxx/include/__random/uniform_real_distribution.h
new file mode 100644
index 0000000000000..967e4e26fd0cc
--- /dev/null
+++ b/libcxx/include/__random/uniform_real_distribution.h
@@ -0,0 +1,160 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/generate_canonical.h>
+#include <iosfwd>
+#include <limits>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __a_;
+ result_type __b_;
+ public:
+ typedef uniform_real_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __a = 0,
+ result_type __b = 1)
+ : __a_(__a), __b_(__b) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __a_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __b_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructors and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ uniform_real_distribution() : uniform_real_distribution(0) {}
+ explicit uniform_real_distribution(result_type __a, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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);
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __p_.a();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __p_.b();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return a();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return b();}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const uniform_real_distribution& __x,
+ const uniform_real_distribution& __y)
+ {return __x.__p_ == __y.__p_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const uniform_real_distribution& __x,
+ const uniform_real_distribution& __y)
+ {return !(__x == __y);}
+};
+
+template<class _RealType>
+template<class _URNG>
+inline
+typename uniform_real_distribution<_RealType>::result_type
+uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
+{
+ return (__p.b() - __p.a())
+ * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
+ + __p.a();
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const uniform_real_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ return __os << __x.a() << __sp << __x.b();
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ uniform_real_distribution<_RT>& __x)
+{
+ typedef uniform_real_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __a;
+ result_type __b;
+ __is >> __a >> __b;
+ if (!__is.fail())
+ __x.param(param_type(__a, __b));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_UNIFORM_REAL_DISTRIBUTION_H
diff --git a/libcxx/include/__random/weibull_distribution.h b/libcxx/include/__random/weibull_distribution.h
new file mode 100644
index 0000000000000..4c5e4e8fff1c5
--- /dev/null
+++ b/libcxx/include/__random/weibull_distribution.h
@@ -0,0 +1,155 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
+#define _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
+
+#include <__config>
+#include <__random/exponential_distribution.h>
+#include <cmath>
+#include <iosfwd>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template<class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS weibull_distribution
+{
+public:
+ // types
+ typedef _RealType result_type;
+
+ class _LIBCPP_TEMPLATE_VIS param_type
+ {
+ result_type __a_;
+ result_type __b_;
+ public:
+ typedef weibull_distribution distribution_type;
+
+ _LIBCPP_INLINE_VISIBILITY
+ explicit param_type(result_type __a = 1, result_type __b = 1)
+ : __a_(__a), __b_(__b) {}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __a_;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __b_;}
+
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator==(const param_type& __x, const param_type& __y)
+ {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
+ friend _LIBCPP_INLINE_VISIBILITY
+ bool operator!=(const param_type& __x, const param_type& __y)
+ {return !(__x == __y);}
+ };
+
+private:
+ param_type __p_;
+
+public:
+ // constructor and reset functions
+#ifndef _LIBCPP_CXX03_LANG
+ _LIBCPP_INLINE_VISIBILITY
+ weibull_distribution() : weibull_distribution(1) {}
+ _LIBCPP_INLINE_VISIBILITY
+ explicit weibull_distribution(result_type __a, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#else
+ _LIBCPP_INLINE_VISIBILITY
+ explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
+ : __p_(param_type(__a, __b)) {}
+#endif
+ _LIBCPP_INLINE_VISIBILITY
+ explicit weibull_distribution(const param_type& __p)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY
+ void reset() {}
+
+ // generating functions
+ template<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());}
+
+ // property functions
+ _LIBCPP_INLINE_VISIBILITY
+ result_type a() const {return __p_.a();}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type b() const {return __p_.b();}
+
+ _LIBCPP_INLINE_VISIBILITY
+ param_type param() const {return __p_;}
+ _LIBCPP_INLINE_VISIBILITY
+ void param(const param_type& __p) {__p_ = __p;}
+
+ _LIBCPP_INLINE_VISIBILITY
+ result_type min() const {return 0;}
+ _LIBCPP_INLINE_VISIBILITY
+ result_type max() const {return numeric_limits<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);}
+};
+
+template <class _CharT, class _Traits, class _RT>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const weibull_distribution<_RT>& __x)
+{
+ __save_flags<_CharT, _Traits> __lx(__os);
+ typedef basic_ostream<_CharT, _Traits> _OStream;
+ __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
+ _OStream::scientific);
+ _CharT __sp = __os.widen(' ');
+ __os.fill(__sp);
+ __os << __x.a() << __sp << __x.b();
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _RT>
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ weibull_distribution<_RT>& __x)
+{
+ typedef weibull_distribution<_RT> _Eng;
+ typedef typename _Eng::result_type result_type;
+ typedef typename _Eng::param_type param_type;
+ __save_flags<_CharT, _Traits> __lx(__is);
+ typedef basic_istream<_CharT, _Traits> _Istream;
+ __is.flags(_Istream::dec | _Istream::skipws);
+ result_type __a;
+ result_type __b;
+ __is >> __a >> __b;
+ if (!__is.fail())
+ __x.param(param_type(__a, __b));
+ return __is;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index f3de49eaf41d7..17755277f65f0 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -680,7 +680,41 @@ module std [system] {
export *
module __random {
- module uniform_int_distribution { private header "__random/uniform_int_distribution.h" }
+ module bernoulli_distribution { private header "__random/bernoulli_distribution.h" }
+ module binomial_distribution { private header "__random/binomial_distribution.h" }
+ module cauchy_distribution { private header "__random/cauchy_distribution.h" }
+ module chi_squared_distribution { private header "__random/chi_squared_distribution.h" }
+ module default_random_engine { private header "__random/default_random_engine.h" }
+ module discard_block_engine { private header "__random/discard_block_engine.h" }
+ module discrete_distribution { private header "__random/discrete_distribution.h" }
+ module exponential_distribution { private header "__random/exponential_distribution.h" }
+ module extreme_value_distribution { private header "__random/extreme_value_distribution.h" }
+ module fisher_f_distribution { private header "__random/fisher_f_distribution.h" }
+ module gamma_distribution { private header "__random/gamma_distribution.h" }
+ module generate_canonical { private header "__random/generate_canonical.h" }
+ module geometric_distribution { private header "__random/geometric_distribution.h" }
+ module independent_bits_engine { private header "__random/independent_bits_engine.h" }
+ module is_seed_sequence { private header "__random/is_seed_sequence.h" }
+ module knuth_b { private header "__random/knuth_b.h" }
+ module linear_congruential_engine { private header "__random/linear_congruential_engine.h" }
+ module log2 { private header "__random/log2.h" }
+ module lognormal_distribution { private header "__random/lognormal_distribution.h" }
+ module mersenne_twister_engine { private header "__random/mersenne_twister_engine.h" }
+ module negative_binomial_distribution { private header "__random/negative_binomial_distribution.h" }
+ module normal_distribution { private header "__random/normal_distribution.h" }
+ module piecewise_constant_distribution { private header "__random/piecewise_constant_distribution.h" }
+ module piecewise_linear_distribution { private header "__random/piecewise_linear_distribution.h" }
+ module poisson_distribution { private header "__random/poisson_distribution.h" }
+ module random_device { private header "__random/random_device.h" }
+ module ranlux { private header "__random/ranlux.h" }
+ module seed_seq { private header "__random/seed_seq.h" }
+ module shuffle_order_engine { private header "__random/shuffle_order_engine.h" }
+ module student_t_distribution { private header "__random/student_t_distribution.h" }
+ module subtract_with_carry_engine { private header "__random/subtract_with_carry_engine.h" }
+ module uniform_int_distribution { private header "__random/uniform_int_distribution.h" }
+ module uniform_random_bit_generator { private header "__random/uniform_random_bit_generator.h" }
+ module uniform_real_distribution { private header "__random/uniform_real_distribution.h" }
+ module weibull_distribution { private header "__random/weibull_distribution.h" }
}
}
module ranges {
diff --git a/libcxx/include/random b/libcxx/include/random
index 72d9855765f8f..9eb70bac00b9e 100644
--- a/libcxx/include/random
+++ b/libcxx/include/random
@@ -1678,5330 +1678,56 @@ class piecewise_linear_distribution
*/
#include <__config>
+#include <__random/bernoulli_distribution.h>
+#include <__random/binomial_distribution.h>
+#include <__random/cauchy_distribution.h>
+#include <__random/chi_squared_distribution.h>
+#include <__random/default_random_engine.h>
+#include <__random/discard_block_engine.h>
+#include <__random/discrete_distribution.h>
+#include <__random/exponential_distribution.h>
+#include <__random/extreme_value_distribution.h>
+#include <__random/fisher_f_distribution.h>
+#include <__random/gamma_distribution.h>
+#include <__random/generate_canonical.h>
+#include <__random/geometric_distribution.h>
+#include <__random/independent_bits_engine.h>
+#include <__random/is_seed_sequence.h>
+#include <__random/knuth_b.h>
+#include <__random/linear_congruential_engine.h>
+#include <__random/log2.h>
+#include <__random/lognormal_distribution.h>
+#include <__random/mersenne_twister_engine.h>
+#include <__random/negative_binomial_distribution.h>
+#include <__random/normal_distribution.h>
+#include <__random/piecewise_constant_distribution.h>
+#include <__random/piecewise_linear_distribution.h>
+#include <__random/poisson_distribution.h>
+#include <__random/random_device.h>
+#include <__random/ranlux.h>
+#include <__random/seed_seq.h>
+#include <__random/shuffle_order_engine.h>
+#include <__random/student_t_distribution.h>
+#include <__random/subtract_with_carry_engine.h>
#include <__random/uniform_int_distribution.h>
-#include <algorithm>
-#include <cmath>
-#include <concepts>
-#include <cstddef>
-#include <cstdint>
+#include <__random/uniform_random_bit_generator.h>
+#include <__random/uniform_real_distribution.h>
+#include <__random/weibull_distribution.h>
#include <initializer_list>
-#include <iosfwd>
-#include <limits>
-#include <numeric>
-#include <string>
-#include <type_traits>
-#include <vector>
+
+#include <algorithm> // for backward compatibility; TODO remove it
+#include <cmath> // for backward compatibility; TODO remove it
+#include <cstddef> // for backward compatibility; TODO remove it
+#include <cstdint> // for backward compatibility; TODO remove it
+#include <iosfwd> // for backward compatibility; TODO remove it
+#include <limits> // for backward compatibility; TODO remove it
+#include <numeric> // for backward compatibility; TODO remove it
+#include <string> // for backward compatibility; TODO remove it
+#include <type_traits> // for backward compatibility; TODO remove it
+#include <vector> // for backward compatibility; TODO remove it
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
-
-// [rand.req.urng]
-template<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 > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
-
-// __is_seed_sequence
-
-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<typename remove_cv<_Sseq>::type, _Engine>::value;
-};
-
-// linear_congruential_engine
-
-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;
-};
-
-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>
-struct __lce_ta;
-
-// 64
-
-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;
- }
-};
-
-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;
- }
-};
-
-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;
- }
-};
-
-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;
- }
-};
-
-// 32
-
-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;
- }
-};
-
-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;
- }
-};
-
-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;
- }
-};
-
-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;
- }
-};
-
-// 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 <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>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
-{
-public:
- // types
- typedef _UIntType result_type;
-
-private:
- result_type __x_;
-
- static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
-
- static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
- static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
- static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
-public:
- static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
- static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
- static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");
-
- // engine characteristics
- static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
- static _LIBCPP_CONSTEXPR const result_type increment = __c;
- static _LIBCPP_CONSTEXPR const result_type modulus = __m;
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
- static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
-
- // constructors and seeding functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- linear_congruential_engine() : linear_congruential_engine(default_seed) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit linear_congruential_engine(result_type __s) { seed(__s); }
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit linear_congruential_engine(result_type __s = default_seed) {
- seed(__s);
- }
-#endif
- template<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))>());}
-
- // 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()();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const linear_congruential_engine& __x,
- const linear_congruential_engine& __y)
- {return __x.__x_ == __y.__x_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const linear_congruential_engine& __x,
- const linear_congruential_engine& __y)
- {return !(__x == __y);}
-
-private:
-
- _LIBCPP_INLINE_VISIBILITY
- void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
- _LIBCPP_INLINE_VISIBILITY
- void seed(true_type, false_type, result_type __s) {__x_ = __s;}
- _LIBCPP_INLINE_VISIBILITY
- void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
- 1 : __s % __m;}
- _LIBCPP_INLINE_VISIBILITY
- void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
-
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
-
- template <class _CharT, class _Traits,
- class _Up, _Up _Ap, _Up _Cp, _Up _Np>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
-
- template <class _CharT, class _Traits,
- class _Up, _Up _Ap, _Up _Cp, _Up _Np>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
-};
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
- _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
- linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
- _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
- linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
- _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
- linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
- _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
- linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
- integral_constant<unsigned, 1>)
-{
- const unsigned __k = 1;
- uint32_t __ar[__k+3];
- __q.generate(__ar, __ar + __k + 3);
- result_type __s = static_cast<result_type>(__ar[3] % __m);
- __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
-}
-
-template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
- integral_constant<unsigned, 2>)
-{
- const unsigned __k = 2;
- uint32_t __ar[__k+3];
- __q.generate(__ar, __ar + __k + 3);
- result_type __s = static_cast<result_type>((__ar[3] +
- ((uint64_t)__ar[4] << 32)) % __m);
- __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
-}
-
-template <class _CharT, class _Traits,
- class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-inline _LIBCPP_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>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- _UIntType __t;
- __is >> __t;
- if (!__is.fail())
- __x.__x_ = __t;
- return __is;
-}
-
-typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
- minstd_rand0;
-typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
- minstd_rand;
-typedef minstd_rand default_random_engine;
-// mersenne_twister_engine
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
-
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
-
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
-
-template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-
-template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
-{
-public:
- // types
- typedef _UIntType result_type;
-
-private:
- result_type __x_[__n];
- size_t __i_;
-
- static_assert( 0 < __m, "mersenne_twister_engine invalid parameters");
- static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
- static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
- static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
- static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters");
- static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
- static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
- static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
- static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
- static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
-public:
- static _LIBCPP_CONSTEXPR const result_type _Min = 0;
- static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
- (result_type(1) << __w) - result_type(1);
- static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
- static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
- static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
- static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
- static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
- static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
-
- // engine characteristics
- static _LIBCPP_CONSTEXPR const size_t word_size = __w;
- static _LIBCPP_CONSTEXPR const size_t state_size = __n;
- static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
- static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
- static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
- static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
- static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
- static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
- static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
- static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
- static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
- static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
- static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
- static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
-
- // constructors and seeding functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit mersenne_twister_engine(result_type __sd = default_seed) {
- seed(__sd);
- }
-#endif
- template<class _Sseq>
- _LIBCPP_INLINE_VISIBILITY
- explicit mersenne_twister_engine(_Sseq& __q,
- typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
- {seed(__q);}
- void seed(result_type __sd = default_seed);
- template<class _Sseq>
- _LIBCPP_INLINE_VISIBILITY
- typename enable_if
- <
- __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
- void
- >::type
- seed(_Sseq& __q)
- {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
-
- // generating functions
- result_type operator()();
- _LIBCPP_INLINE_VISIBILITY
- void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
-
- template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
- friend
- bool
- operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
-
- template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
- friend
- bool
- operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
-
- template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-
- template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
-private:
-
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
-
- template <size_t __count>
- _LIBCPP_INLINE_VISIBILITY
- static
- typename enable_if
- <
- __count < __w,
- result_type
- >::type
- __lshift(result_type __x) {return (__x << __count) & _Max;}
-
- template <size_t __count>
- _LIBCPP_INLINE_VISIBILITY
- static
- typename enable_if
- <
- (__count >= __w),
- result_type
- >::type
- __lshift(result_type) {return result_type(0);}
-
- template <size_t __count>
- _LIBCPP_INLINE_VISIBILITY
- static
- typename enable_if
- <
- __count < _Dt,
- result_type
- >::type
- __rshift(result_type __x) {return __x >> __count;}
-
- template <size_t __count>
- _LIBCPP_INLINE_VISIBILITY
- static
- typename enable_if
- <
- (__count >= _Dt),
- result_type
- >::type
- __rshift(result_type) {return result_type(0);}
-};
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const size_t
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
- _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
- mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
- __t, __c, __l, __f>::seed(result_type __sd)
- _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{ // __w >= 2
- __x_[0] = __sd & _Max;
- for (size_t __i = 1; __i < __n; ++__i)
- __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
- __i_ = 0;
-}
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
- __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
-{
- const unsigned __k = 1;
- uint32_t __ar[__n * __k];
- __q.generate(__ar, __ar + __n * __k);
- for (size_t __i = 0; __i < __n; ++__i)
- __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
- const result_type __mask = __r == _Dt ? result_type(~0) :
- (result_type(1) << __r) - result_type(1);
- __i_ = 0;
- if ((__x_[0] & ~__mask) == 0)
- {
- for (size_t __i = 1; __i < __n; ++__i)
- if (__x_[__i] != 0)
- return;
- __x_[0] = result_type(1) << (__w - 1);
- }
-}
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
- __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
-{
- const unsigned __k = 2;
- uint32_t __ar[__n * __k];
- __q.generate(__ar, __ar + __n * __k);
- for (size_t __i = 0; __i < __n; ++__i)
- __x_[__i] = static_cast<result_type>(
- (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
- const result_type __mask = __r == _Dt ? result_type(~0) :
- (result_type(1) << __r) - result_type(1);
- __i_ = 0;
- if ((__x_[0] & ~__mask) == 0)
- {
- for (size_t __i = 1; __i < __n; ++__i)
- if (__x_[__i] != 0)
- return;
- __x_[0] = result_type(1) << (__w - 1);
- }
-}
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
- _UIntType __a, size_t __u, _UIntType __d, size_t __s,
- _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-_UIntType
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
- __t, __c, __l, __f>::operator()()
-{
- const size_t __j = (__i_ + 1) % __n;
- const result_type __mask = __r == _Dt ? result_type(~0) :
- (result_type(1) << __r) - result_type(1);
- const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
- const size_t __k = (__i_ + __m) % __n;
- __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
- result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
- __i_ = __j;
- __z ^= __lshift<__s>(__z) & __b;
- __z ^= __lshift<__t>(__z) & __c;
- return __z ^ __rshift<__l>(__z);
-}
-
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
- if (__x.__i_ == __y.__i_)
- return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
- if (__x.__i_ == 0 || __y.__i_ == 0)
- {
- size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
- if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
- __y.__x_ + __y.__i_))
- return false;
- if (__x.__i_ == 0)
- return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
- return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
- }
- if (__x.__i_ < __y.__i_)
- {
- size_t __j = _Np - __y.__i_;
- if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
- __y.__x_ + __y.__i_))
- return false;
- if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
- __y.__x_))
- return false;
- return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
- __y.__x_ + (_Np - (__x.__i_ + __j)));
- }
- size_t __j = _Np - __x.__i_;
- if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
- __x.__x_ + __x.__i_))
- return false;
- if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
- __x.__x_))
- return false;
- return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
- __x.__x_ + (_Np - (__y.__i_ + __j)));
-}
-
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
- return !(__x == __y);
-}
-
-template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _Ostream;
- __os.flags(_Ostream::dec | _Ostream::left);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.__x_[__x.__i_];
- for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
- __os << __sp << __x.__x_[__j];
- for (size_t __j = 0; __j < __x.__i_; ++__j)
- __os << __sp << __x.__x_[__j];
- return __os;
-}
-
-template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
- _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
- _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
- _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- _UInt __t[_Np];
- for (size_t __i = 0; __i < _Np; ++__i)
- __is >> __t[__i];
- if (!__is.fail())
- {
- for (size_t __i = 0; __i < _Np; ++__i)
- __x.__x_[__i] = __t[__i];
- __x.__i_ = 0;
- }
- return __is;
-}
-
-typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
- 0x9908b0df, 11, 0xffffffff,
- 7, 0x9d2c5680,
- 15, 0xefc60000,
- 18, 1812433253> mt19937;
-typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
- 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
- 17, 0x71d67fffeda60000ULL,
- 37, 0xfff7eee000000000ULL,
- 43, 6364136223846793005ULL> mt19937_64;
-
-// subtract_with_carry_engine
-
-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>
-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 _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-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>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
-{
-public:
- // types
- typedef _UIntType result_type;
-
-private:
- result_type __x_[__r];
- result_type __c_;
- size_t __i_;
-
- static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
- static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters");
- static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
- static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters");
- static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
-public:
- static _LIBCPP_CONSTEXPR const result_type _Min = 0;
- static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
- (result_type(1) << __w) - result_type(1);
- static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
-
- // engine characteristics
- static _LIBCPP_CONSTEXPR const size_t word_size = __w;
- static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
- static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
- static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
-
- // constructors and seeding functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit subtract_with_carry_engine(result_type __sd = default_seed) {
- seed(__sd);
- }
-#endif
- template<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>());}
-
- // generating functions
- result_type operator()();
- _LIBCPP_INLINE_VISIBILITY
- void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
-
- template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
- friend
- bool
- operator==(
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
-
- template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
- friend
- bool
- operator!=(
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
-
- template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
-
- template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
-
-private:
-
- void seed(result_type __sd, integral_constant<unsigned, 1>);
- void seed(result_type __sd, integral_constant<unsigned, 2>);
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
- template<class _Sseq>
- void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
-};
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
- _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
- _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
- _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
- _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
- subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
- integral_constant<unsigned, 1>)
-{
- linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
- __e(__sd == 0u ? default_seed : __sd);
- for (size_t __i = 0; __i < __r; ++__i)
- __x_[__i] = static_cast<result_type>(__e() & _Max);
- __c_ = __x_[__r-1] == 0;
- __i_ = 0;
-}
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
- integral_constant<unsigned, 2>)
-{
- linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
- __e(__sd == 0u ? default_seed : __sd);
- for (size_t __i = 0; __i < __r; ++__i)
- {
- result_type __e0 = __e();
- __x_[__i] = static_cast<result_type>(
- (__e0 + ((uint64_t)__e() << 32)) & _Max);
- }
- __c_ = __x_[__r-1] == 0;
- __i_ = 0;
-}
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
- integral_constant<unsigned, 1>)
-{
- const unsigned __k = 1;
- uint32_t __ar[__r * __k];
- __q.generate(__ar, __ar + __r * __k);
- for (size_t __i = 0; __i < __r; ++__i)
- __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
- __c_ = __x_[__r-1] == 0;
- __i_ = 0;
-}
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
- integral_constant<unsigned, 2>)
-{
- const unsigned __k = 2;
- uint32_t __ar[__r * __k];
- __q.generate(__ar, __ar + __r * __k);
- for (size_t __i = 0; __i < __r; ++__i)
- __x_[__i] = static_cast<result_type>(
- (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
- __c_ = __x_[__r-1] == 0;
- __i_ = 0;
-}
-
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-_UIntType
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
-{
- const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
- result_type& __xr = __x_[__i_];
- result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
- __xr = (__xs - __xr - __c_) & _Max;
- __c_ = __new_c;
- __i_ = (__i_ + 1) % __r;
- return __xr;
-}
-
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-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>
-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 _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _Ostream;
- __os.flags(_Ostream::dec | _Ostream::left);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.__x_[__x.__i_];
- for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
- __os << __sp << __x.__x_[__j];
- for (size_t __j = 0; __j < __x.__i_; ++__j)
- __os << __sp << __x.__x_[__j];
- __os << __sp << __x.__c_;
- return __os;
-}
-
-template <class _CharT, class _Traits,
- class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- _UInt __t[_Rp+1];
- for (size_t __i = 0; __i < _Rp+1; ++__i)
- __is >> __t[__i];
- if (!__is.fail())
- {
- for (size_t __i = 0; __i < _Rp; ++__i)
- __x.__x_[__i] = __t[__i];
- __x.__c_ = __t[_Rp];
- __x.__i_ = 0;
- }
- return __is;
-}
-
-typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
-typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
-
-// discard_block_engine
-
-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(__r <= INT_MAX, "discard_block_engine invalid parameters");
-public:
- // types
- typedef typename _Engine::result_type result_type;
-
- // engine characteristics
- static _LIBCPP_CONSTEXPR const size_t block_size = __p;
- static _LIBCPP_CONSTEXPR const size_t used_block = __r;
-
-#ifdef _LIBCPP_CXX03_LANG
- static const result_type _Min = _Engine::_Min;
- static const result_type _Max = _Engine::_Max;
-#else
- static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
- static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
-#endif
-
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
-
- // constructors and seeding functions
- _LIBCPP_INLINE_VISIBILITY
- discard_block_engine() : __n_(0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit discard_block_engine(const _Engine& __e)
- : __e_(__e), __n_(0) {}
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit discard_block_engine(_Engine&& __e)
- : __e_(_VSTD::move(__e)), __n_(0) {}
-#endif // _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
- template<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;}
-
- // generating functions
- result_type operator()();
- _LIBCPP_INLINE_VISIBILITY
- void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- const _Engine& base() const _NOEXCEPT {return __e_;}
-
- template<class _Eng, size_t _Pp, size_t _Rp>
- friend
- bool
- operator==(
- const discard_block_engine<_Eng, _Pp, _Rp>& __x,
- const discard_block_engine<_Eng, _Pp, _Rp>& __y);
-
- template<class _Eng, size_t _Pp, size_t _Rp>
- friend
- bool
- operator!=(
- const discard_block_engine<_Eng, _Pp, _Rp>& __x,
- const discard_block_engine<_Eng, _Pp, _Rp>& __y);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Pp, size_t _Rp>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const discard_block_engine<_Eng, _Pp, _Rp>& __x);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Pp, size_t _Rp>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- discard_block_engine<_Eng, _Pp, _Rp>& __x);
-};
-
-template<class _Engine, size_t __p, size_t __r>
- _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
-
-template<class _Engine, size_t __p, size_t __r>
- _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
-
-template<class _Engine, size_t __p, size_t __r>
-typename discard_block_engine<_Engine, __p, __r>::result_type
-discard_block_engine<_Engine, __p, __r>::operator()()
-{
- if (__n_ >= static_cast<int>(__r))
- {
- __e_.discard(__p - __r);
- __n_ = 0;
- }
- ++__n_;
- return __e_();
-}
-
-template<class _Eng, size_t _Pp, size_t _Rp>
-inline _LIBCPP_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_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 _CharT, class _Traits,
- class _Eng, size_t _Pp, size_t _Rp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _Ostream;
- __os.flags(_Ostream::dec | _Ostream::left);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- return __os << __x.__e_ << __sp << __x.__n_;
-}
-
-template <class _CharT, class _Traits,
- class _Eng, size_t _Pp, size_t _Rp>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- _Eng __e;
- int __n;
- __is >> __e >> __n;
- if (!__is.fail())
- {
- __x.__e_ = __e;
- __x.__n_ = __n;
- }
- return __is;
-}
-
-typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
-typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
-
-// independent_bits_engine
-
-template<class _Engine, size_t __w, class _UIntType>
-class _LIBCPP_TEMPLATE_VIS independent_bits_engine
-{
- template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
- class __get_n
- {
- static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
- static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
- static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
- static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
- public:
- static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
- };
-public:
- // types
- typedef _UIntType result_type;
-
-private:
- _Engine __e_;
-
- static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
- static_assert( 0 < __w, "independent_bits_engine invalid parameters");
- static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
-
- typedef typename _Engine::result_type _Engine_result_type;
- typedef typename conditional
- <
- sizeof(_Engine_result_type) <= sizeof(result_type),
- result_type,
- _Engine_result_type
- >::type _Working_result_type;
-#ifdef _LIBCPP_CXX03_LANG
- static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
- + _Working_result_type(1);
-#else
- static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
- + _Working_result_type(1);
-#endif
- static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
- static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
- static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
- static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
- static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
- static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
- static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
- (_Rp >> __w0) << __w0;
- static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
- (_Rp >> (__w0+1)) << (__w0+1);
- static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
- _Engine_result_type(~0) >> (_EDt - __w0) :
- _Engine_result_type(0);
- static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
- _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
- _Engine_result_type(~0);
-public:
- static _LIBCPP_CONSTEXPR const result_type _Min = 0;
- static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
- (result_type(1) << __w) - result_type(1);
- static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
-
- // engine characteristics
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-
- // constructors and seeding functions
- _LIBCPP_INLINE_VISIBILITY
- independent_bits_engine() {}
- _LIBCPP_INLINE_VISIBILITY
- explicit independent_bits_engine(const _Engine& __e)
- : __e_(__e) {}
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit independent_bits_engine(_Engine&& __e)
- : __e_(_VSTD::move(__e)) {}
-#endif // _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
- template<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);}
-
- // 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()();}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- const _Engine& base() const _NOEXCEPT {return __e_;}
-
- template<class _Eng, size_t _Wp, class _UInt>
- friend
- bool
- operator==(
- const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
- const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
-
- template<class _Eng, size_t _Wp, class _UInt>
- friend
- bool
- operator!=(
- const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
- const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Wp, class _UInt>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Wp, class _UInt>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- independent_bits_engine<_Eng, _Wp, _UInt>& __x);
-
-private:
- _LIBCPP_INLINE_VISIBILITY
- result_type __eval(false_type);
- 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>
- _LIBCPP_INLINE_VISIBILITY
- static
- typename enable_if
- <
- (__count >= _Dt),
- result_type
- >::type
- __lshift(result_type) {return result_type(0);}
-};
-
-template<class _Engine, size_t __w, class _UIntType>
-inline
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
-{
- return static_cast<result_type>(__e_() & __mask0);
-}
-
-template<class _Engine, size_t __w, class _UIntType>
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
-{
- result_type _Sp = 0;
- for (size_t __k = 0; __k < __n0; ++__k)
- {
- _Engine_result_type __u;
- do
- {
- __u = __e_() - _Engine::min();
- } while (__u >= __y0);
- _Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
- }
- for (size_t __k = __n0; __k < __n; ++__k)
- {
- _Engine_result_type __u;
- do
- {
- __u = __e_() - _Engine::min();
- } while (__u >= __y1);
- _Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
- }
- return _Sp;
-}
-
-template<class _Eng, size_t _Wp, class _UInt>
-inline _LIBCPP_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_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 _CharT, class _Traits,
- class _Eng, size_t _Wp, class _UInt>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
- return __os << __x.base();
-}
-
-template <class _CharT, class _Traits,
- class _Eng, size_t _Wp, class _UInt>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
- _Eng __e;
- __is >> __e;
- if (!__is.fail())
- __x.__e_ = __e;
- return __is;
-}
-
-// shuffle_order_engine
-
-template <uint64_t _Xp, uint64_t _Yp>
-struct __ugcd
-{
- static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
-};
-
-template <uint64_t _Xp>
-struct __ugcd<_Xp, 0>
-{
- static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
-};
-
-template <uint64_t _Np, uint64_t _Dp>
-class __uratio
-{
- static_assert(_Dp != 0, "__uratio divide by 0");
- static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
-public:
- static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
- static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
-
- typedef __uratio<num, den> type;
-};
-
-template<class _Engine, size_t __k>
-class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
-{
- static_assert(0 < __k, "shuffle_order_engine invalid parameters");
-public:
- // types
- typedef typename _Engine::result_type result_type;
-
-private:
- _Engine __e_;
- result_type _V_[__k];
- result_type _Y_;
-
-public:
- // engine characteristics
- static _LIBCPP_CONSTEXPR const size_t table_size = __k;
-
-#ifdef _LIBCPP_CXX03_LANG
- static const result_type _Min = _Engine::_Min;
- static const result_type _Max = _Engine::_Max;
-#else
- static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
- static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
-#endif
- static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-
- static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
-
- // constructors and seeding functions
- _LIBCPP_INLINE_VISIBILITY
- shuffle_order_engine() {__init();}
- _LIBCPP_INLINE_VISIBILITY
- explicit shuffle_order_engine(const _Engine& __e)
- : __e_(__e) {__init();}
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit shuffle_order_engine(_Engine&& __e)
- : __e_(_VSTD::move(__e)) {__init();}
-#endif // _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
- template<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();}
-
- // 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()();}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- const _Engine& base() const _NOEXCEPT {return __e_;}
-
-private:
- template<class _Eng, size_t _Kp>
- friend
- bool
- operator==(
- const shuffle_order_engine<_Eng, _Kp>& __x,
- const shuffle_order_engine<_Eng, _Kp>& __y);
-
- template<class _Eng, size_t _Kp>
- friend
- bool
- operator!=(
- const shuffle_order_engine<_Eng, _Kp>& __x,
- const shuffle_order_engine<_Eng, _Kp>& __y);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Kp>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const shuffle_order_engine<_Eng, _Kp>& __x);
-
- template <class _CharT, class _Traits,
- class _Eng, size_t _Kp>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- shuffle_order_engine<_Eng, _Kp>& __x);
-
- _LIBCPP_INLINE_VISIBILITY
- void __init()
- {
- for (size_t __i = 0; __i < __k; ++__i)
- _V_[__i] = __e_();
- _Y_ = __e_();
- }
-
- _LIBCPP_INLINE_VISIBILITY
- result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
- _LIBCPP_INLINE_VISIBILITY
- result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
- _LIBCPP_INLINE_VISIBILITY
- result_type __eval2(true_type) {return __evalf<__k, 0>();}
-
- template <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>
- _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 __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<class _Engine, size_t __k>
- _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
-
-template<class _Eng, size_t _Kp>
-bool
-operator==(
- const shuffle_order_engine<_Eng, _Kp>& __x,
- const shuffle_order_engine<_Eng, _Kp>& __y)
-{
- return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
- __x.__e_ == __y.__e_;
-}
-
-template<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 _CharT, class _Traits,
- class _Eng, size_t _Kp>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const shuffle_order_engine<_Eng, _Kp>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _Ostream;
- __os.flags(_Ostream::dec | _Ostream::left);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.__e_ << __sp << __x._V_[0];
- for (size_t __i = 1; __i < _Kp; ++__i)
- __os << __sp << __x._V_[__i];
- return __os << __sp << __x._Y_;
-}
-
-template <class _CharT, class _Traits,
- class _Eng, size_t _Kp>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- shuffle_order_engine<_Eng, _Kp>& __x)
-{
- typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- _Eng __e;
- result_type _Vp[_Kp+1];
- __is >> __e;
- for (size_t __i = 0; __i < _Kp+1; ++__i)
- __is >> _Vp[__i];
- if (!__is.fail())
- {
- __x.__e_ = __e;
- for (size_t __i = 0; __i < _Kp; ++__i)
- __x._V_[__i] = _Vp[__i];
- __x._Y_ = _Vp[_Kp];
- }
- return __is;
-}
-
-typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
-
-// random_device
-
-#if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE)
-
-class _LIBCPP_TYPE_VIS random_device
-{
-#ifdef _LIBCPP_USING_DEV_RANDOM
- int __f_;
-#endif // defined(_LIBCPP_USING_DEV_RANDOM)
-public:
- // types
- typedef unsigned result_type;
-
- // generator characteristics
- static _LIBCPP_CONSTEXPR const result_type _Min = 0;
- static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
-
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
- _LIBCPP_INLINE_VISIBILITY
- static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
-
- // constructors
-#ifndef _LIBCPP_CXX03_LANG
- random_device() : random_device("/dev/urandom") {}
- explicit random_device(const string& __token);
-#else
- explicit random_device(const string& __token = "/dev/urandom");
-#endif
- ~random_device();
-
- // generating functions
- result_type operator()();
-
- // property functions
- double entropy() const _NOEXCEPT;
-
-private:
- // no copy functions
- random_device(const random_device&); // = delete;
- random_device& operator=(const random_device&); // = delete;
-};
-
-#endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE
-
-// seed_seq
-
-class _LIBCPP_TEMPLATE_VIS seed_seq
-{
-public:
- // types
- typedef uint32_t result_type;
-
-private:
- vector<result_type> __v_;
-
- template<class _InputIterator>
- void init(_InputIterator __first, _InputIterator __last);
-public:
- // constructors
- _LIBCPP_INLINE_VISIBILITY
- seed_seq() _NOEXCEPT {}
-#ifndef _LIBCPP_CXX03_LANG
- template<class _Tp>
- _LIBCPP_INLINE_VISIBILITY
- 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)
- {init(__first, __last);}
-
- // generating functions
- template<class _RandomAccessIterator>
- 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);}
-
-private:
- // no copy functions
- seed_seq(const seed_seq&); // = delete;
- void operator=(const seed_seq&); // = delete;
-
- _LIBCPP_INLINE_VISIBILITY
- static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
-};
-
-template<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)
- {
- _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;
- }
- for (size_t __k = 1; __k <= __s; ++__k)
- {
- const size_t __kmodn = __k % __n;
- const size_t __kpmodn = (__k + __p) % __n;
- result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
- ^ __first[(__k - 1) % __n]);
- __first[__kpmodn] += __r;
- __r += __kmodn + __v_[__k-1];
- __first[(__k + __q) % __n] += __r;
- __first[__kmodn] = __r;
- }
- for (size_t __k = __s + 1; __k < __m; ++__k)
- {
- const size_t __kmodn = __k % __n;
- const size_t __kpmodn = (__k + __p) % __n;
- result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
- ^ __first[(__k - 1) % __n]);
- __first[__kpmodn] += __r;
- __r += __kmodn;
- __first[(__k + __q) % __n] += __r;
- __first[__kmodn] = __r;
- }
- for (size_t __k = __m; __k < __m + __n; ++__k)
- {
- const size_t __kmodn = __k % __n;
- const size_t __kpmodn = (__k + __p) % __n;
- result_type __r = 1566083941 * _Tp(__first[__kmodn] +
- __first[__kpmodn] +
- __first[(__k - 1) % __n]);
- __first[__kpmodn] ^= __r;
- __r -= __kmodn;
- __first[(__k + __q) % __n] ^= __r;
- __first[__kmodn] = __r;
- }
- }
-}
-
-// generate_canonical
-
-template<class _RealType, size_t __bits, class _URNG>
-_RealType
-generate_canonical(_URNG& __g)
-{
- const size_t _Dt = numeric_limits<_RealType>::digits;
- const size_t __b = _Dt < __bits ? _Dt : __bits;
-#ifdef _LIBCPP_CXX03_LANG
- const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
-#else
- const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
-#endif
- const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
- const _RealType _Rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
- _RealType __base = _Rp;
- _RealType _Sp = __g() - _URNG::min();
- for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
- _Sp += (__g() - _URNG::min()) * __base;
- return _Sp / __base;
-}
-
-// uniform_real_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __a_;
- result_type __b_;
- public:
- typedef uniform_real_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __a = 0,
- result_type __b = 1)
- : __a_(__a), __b_(__b) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __a_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __b_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- uniform_real_distribution() : uniform_real_distribution(0) {}
- explicit uniform_real_distribution(result_type __a, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __p_.a();}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __p_.b();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return a();}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return b();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const uniform_real_distribution& __x,
- const uniform_real_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const uniform_real_distribution& __x,
- const uniform_real_distribution& __y)
- {return !(__x == __y);}
-};
-
-template<class _RealType>
-template<class _URNG>
-inline
-typename uniform_real_distribution<_RealType>::result_type
-uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- return (__p.b() - __p.a())
- * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
- + __p.a();
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const uniform_real_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- return __os << __x.a() << __sp << __x.b();
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- uniform_real_distribution<_RT>& __x)
-{
- typedef uniform_real_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __a;
- result_type __b;
- __is >> __a >> __b;
- if (!__is.fail())
- __x.param(param_type(__a, __b));
- return __is;
-}
-
-// bernoulli_distribution
-
-class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
-{
-public:
- // types
- typedef bool result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- double __p_;
- public:
- typedef bernoulli_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(double __p = 0.5) : __p_(__p) {}
-
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- bernoulli_distribution() : bernoulli_distribution(0.5) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_.p();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return false;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return true;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const bernoulli_distribution& __x,
- const bernoulli_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const bernoulli_distribution& __x,
- const bernoulli_distribution& __y)
- {return !(__x == __y);}
-};
-
-template<class _URNG>
-inline
-bernoulli_distribution::result_type
-bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
-{
- uniform_real_distribution<double> __gen;
- return __gen(__g) < __p.p();
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- return __os << __x.p();
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
-{
- typedef bernoulli_distribution _Eng;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- double __p;
- __is >> __p;
- if (!__is.fail())
- __x.param(param_type(__p));
- return __is;
-}
-
-// binomial_distribution
-
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS binomial_distribution
-{
-public:
- // types
- typedef _IntType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __t_;
- double __p_;
- double __pr_;
- double __odds_ratio_;
- result_type __r0_;
- public:
- typedef binomial_distribution distribution_type;
-
- explicit param_type(result_type __t = 1, double __p = 0.5);
-
- _LIBCPP_INLINE_VISIBILITY
- result_type t() const {return __t_;}
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
-
- friend class binomial_distribution;
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- binomial_distribution() : binomial_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit binomial_distribution(result_type __t, double __p = 0.5)
- : __p_(param_type(__t, __p)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
- : __p_(param_type(__t, __p)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type t() const {return __p_.t();}
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_.p();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return t();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const binomial_distribution& __x,
- const binomial_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const binomial_distribution& __x,
- const binomial_distribution& __y)
- {return !(__x == __y);}
-};
-
-#ifndef _LIBCPP_MSVCRT_LIKE
-extern "C" double lgamma_r(double, int *);
-#endif
-
-inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
-#if defined(_LIBCPP_MSVCRT_LIKE)
- return lgamma(__d);
-#else
- int __sign;
- return lgamma_r(__d, &__sign);
-#endif
-}
-
-template<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(__libcpp_lgamma(__t_ + 1.) -
- __libcpp_lgamma(__r0_ + 1.) -
- __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
- (__t_ - __r0_) * _VSTD::log(1 - __p_));
- __odds_ratio_ = __p_ / (1 - __p_);
- }
-}
-
-// Reference: Kemp, C.D. (1986). `A modal method for generating binomial
-// variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
-template<class _IntType>
-template<class _URNG>
-_IntType
-binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
-{
- if (__pr.__t_ == 0 || __pr.__p_ == 0)
- return 0;
- if (__pr.__p_ == 1)
- return __pr.__t_;
- uniform_real_distribution<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>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const binomial_distribution<_IntType>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- return __os << __x.t() << __sp << __x.p();
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- binomial_distribution<_IntType>& __x)
-{
- typedef binomial_distribution<_IntType> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __t;
- double __p;
- __is >> __t >> __p;
- if (!__is.fail())
- __x.param(param_type(__t, __p));
- return __is;
-}
-
-// exponential_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS exponential_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __lambda_;
- public:
- typedef exponential_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type lambda() const {return __lambda_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__lambda_ == __y.__lambda_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- exponential_distribution() : exponential_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit exponential_distribution(result_type __lambda)
- : __p_(param_type(__lambda)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit exponential_distribution(result_type __lambda = 1)
- : __p_(param_type(__lambda)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type lambda() const {return __p_.lambda();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _RealType>
-template<class _URNG>
-_RealType
-exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- return -_VSTD::log
- (
- result_type(1) -
- _VSTD::generate_canonical<result_type,
- numeric_limits<result_type>::digits>(__g)
- )
- / __p.lambda();
-}
-
-template <class _CharT, class _Traits, class _RealType>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const exponential_distribution<_RealType>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- return __os << __x.lambda();
-}
-
-template <class _CharT, class _Traits, class _RealType>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- exponential_distribution<_RealType>& __x)
-{
- typedef exponential_distribution<_RealType> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __lambda;
- __is >> __lambda;
- if (!__is.fail())
- __x.param(param_type(__lambda));
- return __is;
-}
-
-// normal_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS normal_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __mean_;
- result_type __stddev_;
- public:
- typedef normal_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __mean = 0, result_type __stddev = 1)
- : __mean_(__mean), __stddev_(__stddev) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type mean() const {return __mean_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type stddev() const {return __stddev_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
- result_type _V_;
- bool _V_hot_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- normal_distribution() : normal_distribution(0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit normal_distribution(result_type __mean, result_type __stddev = 1)
- : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit normal_distribution(result_type __mean = 0,
- result_type __stddev = 1)
- : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit normal_distribution(const param_type& __p)
- : __p_(__p), _V_hot_(false) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {_V_hot_ = false;}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type mean() const {return __p_.mean();}
- _LIBCPP_INLINE_VISIBILITY
- result_type stddev() const {return __p_.stddev();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return -numeric_limits<result_type>::infinity();}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const normal_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- normal_distribution<_RT>& __x);
-};
-
-template <class _RealType>
-template<class _URNG>
-_RealType
-normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- 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 _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const normal_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
- if (__x._V_hot_)
- __os << __sp << __x._V_;
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- normal_distribution<_RT>& __x)
-{
- typedef normal_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __mean;
- result_type __stddev;
- result_type _Vp = 0;
- bool _V_hot = false;
- __is >> __mean >> __stddev >> _V_hot;
- if (_V_hot)
- __is >> _Vp;
- if (!__is.fail())
- {
- __x.param(param_type(__mean, __stddev));
- __x._V_hot_ = _V_hot;
- __x._V_ = _Vp;
- }
- return __is;
-}
-
-// lognormal_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS lognormal_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- normal_distribution<result_type> __nd_;
- public:
- typedef lognormal_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __m = 0, result_type __s = 1)
- : __nd_(__m, __s) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type m() const {return __nd_.mean();}
- _LIBCPP_INLINE_VISIBILITY
- result_type s() const {return __nd_.stddev();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__nd_ == __y.__nd_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- friend class lognormal_distribution;
-
- template <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);
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- lognormal_distribution() : lognormal_distribution(0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit lognormal_distribution(result_type __m, result_type __s = 1)
- : __p_(param_type(__m, __s)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit lognormal_distribution(result_type __m = 0,
- result_type __s = 1)
- : __p_(param_type(__m, __s)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit lognormal_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {__p_.__nd_.reset();}
-
- // generating functions
- template<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 _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type m() const {return __p_.m();}
- _LIBCPP_INLINE_VISIBILITY
- result_type s() const {return __p_.s();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<result_type>::infinity();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const lognormal_distribution& __x,
- const lognormal_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const lognormal_distribution& __x,
- const lognormal_distribution& __y)
- {return !(__x == __y);}
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const lognormal_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- lognormal_distribution<_RT>& __x);
-};
-
-template <class _CharT, class _Traits, class _RT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const lognormal_distribution<_RT>& __x)
-{
- return __os << __x.__p_.__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.__p_.__nd_;
-}
-
-// poisson_distribution
-
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS poisson_distribution
-{
-public:
- // types
- typedef _IntType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- double __mean_;
- double __s_;
- double __d_;
- double __l_;
- double __omega_;
- double __c0_;
- double __c1_;
- double __c2_;
- double __c3_;
- double __c_;
-
- public:
- typedef poisson_distribution distribution_type;
-
- explicit param_type(double __mean = 1.0);
-
- _LIBCPP_INLINE_VISIBILITY
- double mean() const {return __mean_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__mean_ == __y.__mean_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
-
- friend class poisson_distribution;
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- poisson_distribution() : poisson_distribution(1.0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit poisson_distribution(double __mean)
- : __p_(__mean) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit poisson_distribution(double __mean = 1.0)
- : __p_(__mean) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- double mean() const {return __p_.mean();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-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_;
- }
-}
-
-template <class _IntType>
-template<class _URNG>
-_IntType
-poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
- 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 = _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;
- }
- }
- }
- return _VSTD::__clamp_to_integral<result_type>(__tx);
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const poisson_distribution<_IntType>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- return __os << __x.mean();
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- poisson_distribution<_IntType>& __x)
-{
- typedef poisson_distribution<_IntType> _Eng;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- double __mean;
- __is >> __mean;
- if (!__is.fail())
- __x.param(param_type(__mean));
- return __is;
-}
-
-// weibull_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS weibull_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __a_;
- result_type __b_;
- public:
- typedef weibull_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __a = 1, result_type __b = 1)
- : __a_(__a), __b_(__b) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __a_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __b_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- weibull_distribution() : weibull_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit weibull_distribution(result_type __a, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit weibull_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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());}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __p_.a();}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __p_.b();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const weibull_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.a() << __sp << __x.b();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- weibull_distribution<_RT>& __x)
-{
- typedef weibull_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __a;
- result_type __b;
- __is >> __a >> __b;
- if (!__is.fail())
- __x.param(param_type(__a, __b));
- return __is;
-}
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __a_;
- result_type __b_;
- public:
- typedef extreme_value_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __a = 0, result_type __b = 1)
- : __a_(__a), __b_(__b) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __a_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __b_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- extreme_value_distribution() : extreme_value_distribution(0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit extreme_value_distribution(result_type __a, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit extreme_value_distribution(result_type __a = 0,
- result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit extreme_value_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __p_.a();}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __p_.b();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return -numeric_limits<result_type>::infinity();}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-};
-
-template<class _RealType>
-template<class _URNG>
-_RealType
-extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- return __p.a() - __p.b() *
- _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const extreme_value_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.a() << __sp << __x.b();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- extreme_value_distribution<_RT>& __x)
-{
- typedef extreme_value_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __a;
- result_type __b;
- __is >> __a >> __b;
- if (!__is.fail())
- __x.param(param_type(__a, __b));
- return __is;
-}
-
-// gamma_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS gamma_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __alpha_;
- result_type __beta_;
- public:
- typedef gamma_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __alpha = 1, result_type __beta = 1)
- : __alpha_(__alpha), __beta_(__beta) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type alpha() const {return __alpha_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type beta() const {return __beta_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- gamma_distribution() : gamma_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
- : __p_(param_type(__alpha, __beta)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit gamma_distribution(result_type __alpha = 1,
- result_type __beta = 1)
- : __p_(param_type(__alpha, __beta)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit gamma_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type alpha() const {return __p_.alpha();}
- _LIBCPP_INLINE_VISIBILITY
- result_type beta() const {return __p_.beta();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _RealType>
-template<class _URNG>
-_RealType
-gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- 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;
- }
- }
- }
- }
- else // __a < 1
- {
- while (true)
- {
- const result_type __u = __gen(__g);
- const result_type __es = __egen(__g);
- if (__u <= 1 - __a)
- {
- __x = _VSTD::pow(__u, 1 / __a);
- if (__x <= __es)
- break;
- }
- else
- {
- const result_type __e = -_VSTD::log((1-__u)/__a);
- __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
- if (__x <= __e + __es)
- break;
- }
- }
- }
- return __x * __p.beta();
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const gamma_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.alpha() << __sp << __x.beta();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- gamma_distribution<_RT>& __x)
-{
- typedef gamma_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __alpha;
- result_type __beta;
- __is >> __alpha >> __beta;
- if (!__is.fail())
- __x.param(param_type(__alpha, __beta));
- return __is;
-}
-
-// negative_binomial_distribution
-
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
-{
-public:
- // types
- typedef _IntType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __k_;
- double __p_;
- public:
- typedef negative_binomial_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __k = 1, double __p = 0.5)
- : __k_(__k), __p_(__p) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type k() const {return __k_;}
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- negative_binomial_distribution() : negative_binomial_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
- : __p_(__k, __p) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit negative_binomial_distribution(result_type __k = 1,
- double __p = 0.5)
- : __p_(__k, __p) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type k() const {return __p_.k();}
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_.p();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _IntType>
-template<class _URNG>
-_IntType
-negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
- result_type __k = __pr.k();
- double __p = __pr.p();
- if (__k <= 21 * __p)
- {
- bernoulli_distribution __gen(__p);
- result_type __f = 0;
- result_type __s = 0;
- while (__s < __k)
- {
- if (__gen(__urng))
- ++__s;
- else
- ++__f;
- }
- return __f;
- }
- return poisson_distribution<result_type>(gamma_distribution<double>
- (__k, (1-__p)/__p)(__urng))(__urng);
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const negative_binomial_distribution<_IntType>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- return __os << __x.k() << __sp << __x.p();
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- negative_binomial_distribution<_IntType>& __x)
-{
- typedef negative_binomial_distribution<_IntType> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __k;
- double __p;
- __is >> __k >> __p;
- if (!__is.fail())
- __x.param(param_type(__k, __p));
- return __is;
-}
-
-// geometric_distribution
-
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS geometric_distribution
-{
-public:
- // types
- typedef _IntType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- double __p_;
- public:
- typedef geometric_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(double __p = 0.5) : __p_(__p) {}
-
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructors and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- geometric_distribution() : geometric_distribution(0.5) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit geometric_distribution(double __p)
- : __p_(__p) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit geometric_distribution(double __p = 0.5)
- : __p_(__p) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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);}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- double p() const {return __p_.p();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _CharT, class _Traits, class _IntType>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const geometric_distribution<_IntType>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- return __os << __x.p();
-}
-
-template <class _CharT, class _Traits, class _IntType>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- geometric_distribution<_IntType>& __x)
-{
- typedef geometric_distribution<_IntType> _Eng;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- double __p;
- __is >> __p;
- if (!__is.fail())
- __x.param(param_type(__p));
- return __is;
-}
-
-// chi_squared_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __n_;
- public:
- typedef chi_squared_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __n = 1) : __n_(__n) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __n_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__n_ == __y.__n_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- chi_squared_distribution() : chi_squared_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit chi_squared_distribution(result_type __n)
- : __p_(param_type(__n)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit chi_squared_distribution(result_type __n = 1)
- : __p_(param_type(__n)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit chi_squared_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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);}
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __p_.n();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const chi_squared_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- __os << __x.n();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- chi_squared_distribution<_RT>& __x)
-{
- typedef chi_squared_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __n;
- __is >> __n;
- if (!__is.fail())
- __x.param(param_type(__n));
- return __is;
-}
-
-// cauchy_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS cauchy_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __a_;
- result_type __b_;
- public:
- typedef cauchy_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __a = 0, result_type __b = 1)
- : __a_(__a), __b_(__b) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __a_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __b_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- cauchy_distribution() : cauchy_distribution(0) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit cauchy_distribution(result_type __a, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
- : __p_(param_type(__a, __b)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit cauchy_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<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);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type a() const {return __p_.a();}
- _LIBCPP_INLINE_VISIBILITY
- result_type b() const {return __p_.b();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return -numeric_limits<result_type>::infinity();}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-};
-
-template <class _RealType>
-template<class _URNG>
-inline
-_RealType
-cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- 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 _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const cauchy_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.a() << __sp << __x.b();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- cauchy_distribution<_RT>& __x)
-{
- typedef cauchy_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __a;
- result_type __b;
- __is >> __a >> __b;
- if (!__is.fail())
- __x.param(param_type(__a, __b));
- return __is;
-}
-
-// fisher_f_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __m_;
- result_type __n_;
- public:
- typedef fisher_f_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __m = 1, result_type __n = 1)
- : __m_(__m), __n_(__n) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type m() const {return __m_;}
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __n_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- fisher_f_distribution() : fisher_f_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit fisher_f_distribution(result_type __m, result_type __n = 1)
- : __p_(param_type(__m, __n)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
- : __p_(param_type(__m, __n)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit fisher_f_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type m() const {return __p_.m();}
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __p_.n();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return numeric_limits<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);}
-};
-
-template <class _RealType>
-template<class _URNG>
-_RealType
-fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- 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>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const fisher_f_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- __os << __x.m() << __sp << __x.n();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- fisher_f_distribution<_RT>& __x)
-{
- typedef fisher_f_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __m;
- result_type __n;
- __is >> __m >> __n;
- if (!__is.fail())
- __x.param(param_type(__m, __n));
- return __is;
-}
-
-// student_t_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS student_t_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- result_type __n_;
- public:
- typedef student_t_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- explicit param_type(result_type __n = 1) : __n_(__n) {}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __n_;}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const param_type& __x, const param_type& __y)
- {return __x.__n_ == __y.__n_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const param_type& __x, const param_type& __y)
- {return !(__x == __y);}
- };
-
-private:
- param_type __p_;
- normal_distribution<result_type> __nd_;
-
-public:
- // constructor and reset functions
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- student_t_distribution() : student_t_distribution(1) {}
- _LIBCPP_INLINE_VISIBILITY
- explicit student_t_distribution(result_type __n)
- : __p_(param_type(__n)) {}
-#else
- _LIBCPP_INLINE_VISIBILITY
- explicit student_t_distribution(result_type __n = 1)
- : __p_(param_type(__n)) {}
-#endif
- _LIBCPP_INLINE_VISIBILITY
- explicit student_t_distribution(const param_type& __p)
- : __p_(__p) {}
- _LIBCPP_INLINE_VISIBILITY
- void reset() {__nd_.reset();}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- result_type n() const {return __p_.n();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return -numeric_limits<result_type>::infinity();}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-};
-
-template <class _RealType>
-template<class _URNG>
-_RealType
-student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- gamma_distribution<result_type> __gd(__p.n() * .5, 2);
- return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const student_t_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- __os << __x.n();
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- student_t_distribution<_RT>& __x)
-{
- typedef student_t_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- typedef typename _Eng::param_type param_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- result_type __n;
- __is >> __n;
- if (!__is.fail())
- __x.param(param_type(__n));
- return __is;
-}
-
-// discrete_distribution
-
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS discrete_distribution
-{
-public:
- // types
- typedef _IntType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- vector<double> __p_;
- public:
- typedef discrete_distribution distribution_type;
-
- _LIBCPP_INLINE_VISIBILITY
- param_type() {}
- template<class _InputIterator>
- _LIBCPP_INLINE_VISIBILITY
- 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();}
-#endif // _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- param_type(size_t __nw, double __xmin, double __xmax,
- _UnaryOperation __fw);
-
- 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);}
-
- private:
- void __init();
-
- friend class discrete_distribution;
-
- template <class _CharT, class _Traits, class _IT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const discrete_distribution<_IT>& __x);
-
- template <class _CharT, class _Traits, class _IT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- discrete_distribution<_IT>& __x);
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
- _LIBCPP_INLINE_VISIBILITY
- discrete_distribution() {}
- template<class _InputIterator>
- _LIBCPP_INLINE_VISIBILITY
- discrete_distribution(_InputIterator __f, _InputIterator __l)
- : __p_(__f, __l) {}
-#ifndef _LIBCPP_CXX03_LANG
- _LIBCPP_INLINE_VISIBILITY
- 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() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
-
- // property functions
- _LIBCPP_INLINE_VISIBILITY
- 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_INLINE_VISIBILITY
- result_type min() const {return 0;}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return __p_.__p_.size();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const discrete_distribution& __x,
- const discrete_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const discrete_distribution& __x,
- const discrete_distribution& __y)
- {return !(__x == __y);}
-
- template <class _CharT, class _Traits, class _IT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const discrete_distribution<_IT>& __x);
-
- template <class _CharT, class _Traits, class _IT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- discrete_distribution<_IT>& __x);
-};
-
-template<class _IntType>
-template<class _UnaryOperation>
-discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
- double __xmin,
- double __xmax,
- _UnaryOperation __fw)
-{
- if (__nw > 1)
- {
- __p_.reserve(__nw - 1);
- double __d = (__xmax - __xmin) / __nw;
- double __d2 = __d / 2;
- for (size_t __k = 0; __k < __nw; ++__k)
- __p_.push_back(__fw(__xmin + __k * __d + __d2));
- __init();
- }
-}
-
-template<class _IntType>
-void
-discrete_distribution<_IntType>::param_type::__init()
-{
- if (!__p_.empty())
- {
- if (__p_.size() > 1)
- {
- double __s = _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);
- _VSTD::adjacent_
diff erence(__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)
-{
- 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 _CharT, class _Traits, class _IT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const discrete_distribution<_IT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- size_t __n = __x.__p_.__p_.size();
- __os << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__p_[__i];
- return __os;
-}
-
-template <class _CharT, class _Traits, class _IT>
-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;
-}
-
-// piecewise_constant_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- vector<result_type> __b_;
- vector<result_type> __densities_;
- vector<result_type> __areas_;
- public:
- typedef piecewise_constant_distribution distribution_type;
-
- param_type();
- template<class _InputIteratorB, class _InputIteratorW>
- param_type(_InputIteratorB __fB, _InputIteratorB __lB,
- _InputIteratorW __fW);
-#ifndef _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif // _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- param_type(size_t __nw, result_type __xmin, result_type __xmax,
- _UnaryOperation __fw);
- param_type(param_type const&) = default;
- param_type & operator=(const param_type& __rhs);
-
- _LIBCPP_INLINE_VISIBILITY
- vector<result_type> intervals() const {return __b_;}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-
- private:
- void __init();
-
- friend class piecewise_constant_distribution;
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_constant_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- piecewise_constant_distribution<_RT>& __x);
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
- _LIBCPP_INLINE_VISIBILITY
- piecewise_constant_distribution() {}
- template<class _InputIteratorB, class _InputIteratorW>
- _LIBCPP_INLINE_VISIBILITY
- piecewise_constant_distribution(_InputIteratorB __fB,
- _InputIteratorB __lB,
- _InputIteratorW __fW)
- : __p_(__fB, __lB, __fW) {}
-
-#ifndef _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- _LIBCPP_INLINE_VISIBILITY
- 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) {}
-
- _LIBCPP_INLINE_VISIBILITY
- explicit piecewise_constant_distribution(const param_type& __p)
- : __p_(__p) {}
-
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> 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();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return __p_.__b_.front();}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return __p_.__b_.back();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const piecewise_constant_distribution& __x,
- const piecewise_constant_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const piecewise_constant_distribution& __x,
- const piecewise_constant_distribution& __y)
- {return !(__x == __y);}
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_constant_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- piecewise_constant_distribution<_RT>& __x);
-};
-
-template<class _RealType>
-typename piecewise_constant_distribution<_RealType>::param_type &
-piecewise_constant_distribution<_RealType>::param_type::operator=
- (const param_type& __rhs)
-{
-// These can throw
- __b_.reserve (__rhs.__b_.size ());
- __densities_.reserve(__rhs.__densities_.size());
- __areas_.reserve (__rhs.__areas_.size());
-
-// These can not throw
- __b_ = __rhs.__b_;
- __densities_ = __rhs.__densities_;
- __areas_ = __rhs.__areas_;
- return *this;
-}
-
-template<class _RealType>
-void
-piecewise_constant_distribution<_RealType>::param_type::__init()
-{
- // __densities_ contains non-normalized areas
- result_type __total_area = _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>
-piecewise_constant_distribution<_RealType>::param_type::param_type()
- : __b_(2),
- __densities_(1, 1.0),
- __areas_(1, 0.0)
-{
- __b_[1] = 1;
-}
-
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
-piecewise_constant_distribution<_RealType>::param_type::param_type(
- _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
- : __b_(__fB, __lB)
-{
- if (__b_.size() < 2)
- {
- __b_.resize(2);
- __b_[0] = 0;
- __b_[1] = 1;
- __densities_.assign(1, 1.0);
- __areas_.assign(1, 0.0);
- }
- else
- {
- __densities_.reserve(__b_.size() - 1);
- for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
- __densities_.push_back(*__fW);
- __init();
- }
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _RealType>
-template<class _UnaryOperation>
-piecewise_constant_distribution<_RealType>::param_type::param_type(
- initializer_list<result_type> __bl, _UnaryOperation __fw)
- : __b_(__bl.begin(), __bl.end())
-{
- if (__b_.size() < 2)
- {
- __b_.resize(2);
- __b_[0] = 0;
- __b_[1] = 1;
- __densities_.assign(1, 1.0);
- __areas_.assign(1, 0.0);
- }
- else
- {
- __densities_.reserve(__b_.size() - 1);
- for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
- __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
- __init();
- }
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-template<class _RealType>
-template<class _UnaryOperation>
-piecewise_constant_distribution<_RealType>::param_type::param_type(
- size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
- : __b_(__nw == 0 ? 2 : __nw + 1)
-{
- size_t __n = __b_.size() - 1;
- result_type __d = (__xmax - __xmin) / __n;
- __densities_.reserve(__n);
- for (size_t __i = 0; __i < __n; ++__i)
- {
- __b_[__i] = __xmin + __i * __d;
- __densities_.push_back(__fw(__b_[__i] + __d*.5));
- }
- __b_[__n] = __xmax;
- __init();
-}
-
-template<class _RealType>
-template<class _URNG>
-_RealType
-piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- typedef uniform_real_distribution<result_type> _Gen;
- result_type __u = _Gen()(__g);
- ptr
diff _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 _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_constant_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- size_t __n = __x.__p_.__b_.size();
- __os << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__b_[__i];
- __n = __x.__p_.__densities_.size();
- __os << __sp << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__densities_[__i];
- __n = __x.__p_.__areas_.size();
- __os << __sp << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__areas_[__i];
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-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;
-}
-
-// piecewise_linear_distribution
-
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
-{
-public:
- // types
- typedef _RealType result_type;
-
- class _LIBCPP_TEMPLATE_VIS param_type
- {
- vector<result_type> __b_;
- vector<result_type> __densities_;
- vector<result_type> __areas_;
- public:
- typedef piecewise_linear_distribution distribution_type;
-
- param_type();
- template<class _InputIteratorB, class _InputIteratorW>
- param_type(_InputIteratorB __fB, _InputIteratorB __lB,
- _InputIteratorW __fW);
-#ifndef _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif // _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- param_type(size_t __nw, result_type __xmin, result_type __xmax,
- _UnaryOperation __fw);
- param_type(param_type const&) = default;
- param_type & operator=(const param_type& __rhs);
-
- _LIBCPP_INLINE_VISIBILITY
- vector<result_type> intervals() const {return __b_;}
- _LIBCPP_INLINE_VISIBILITY
- 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);}
-
- private:
- void __init();
-
- friend class piecewise_linear_distribution;
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_linear_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- piecewise_linear_distribution<_RT>& __x);
- };
-
-private:
- param_type __p_;
-
-public:
- // constructor and reset functions
- _LIBCPP_INLINE_VISIBILITY
- piecewise_linear_distribution() {}
- template<class _InputIteratorB, class _InputIteratorW>
- _LIBCPP_INLINE_VISIBILITY
- piecewise_linear_distribution(_InputIteratorB __fB,
- _InputIteratorB __lB,
- _InputIteratorW __fW)
- : __p_(__fB, __lB, __fW) {}
-
-#ifndef _LIBCPP_CXX03_LANG
- template<class _UnaryOperation>
- _LIBCPP_INLINE_VISIBILITY
- 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) {}
-
- _LIBCPP_INLINE_VISIBILITY
- explicit piecewise_linear_distribution(const param_type& __p)
- : __p_(__p) {}
-
- _LIBCPP_INLINE_VISIBILITY
- void reset() {}
-
- // generating functions
- template<class _URNG>
- _LIBCPP_INLINE_VISIBILITY
- result_type operator()(_URNG& __g)
- {return (*this)(__g, __p_);}
- template<class _URNG> 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();}
-
- _LIBCPP_INLINE_VISIBILITY
- param_type param() const {return __p_;}
- _LIBCPP_INLINE_VISIBILITY
- void param(const param_type& __p) {__p_ = __p;}
-
- _LIBCPP_INLINE_VISIBILITY
- result_type min() const {return __p_.__b_.front();}
- _LIBCPP_INLINE_VISIBILITY
- result_type max() const {return __p_.__b_.back();}
-
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator==(const piecewise_linear_distribution& __x,
- const piecewise_linear_distribution& __y)
- {return __x.__p_ == __y.__p_;}
- friend _LIBCPP_INLINE_VISIBILITY
- bool operator!=(const piecewise_linear_distribution& __x,
- const piecewise_linear_distribution& __y)
- {return !(__x == __y);}
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_linear_distribution<_RT>& __x);
-
- template <class _CharT, class _Traits, class _RT>
- friend
- basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __is,
- piecewise_linear_distribution<_RT>& __x);
-};
-
-template<class _RealType>
-typename piecewise_linear_distribution<_RealType>::param_type &
-piecewise_linear_distribution<_RealType>::param_type::operator=
- (const param_type& __rhs)
-{
-// These can throw
- __b_.reserve (__rhs.__b_.size ());
- __densities_.reserve(__rhs.__densities_.size());
- __areas_.reserve (__rhs.__areas_.size());
-
-// These can not throw
- __b_ = __rhs.__b_;
- __densities_ = __rhs.__densities_;
- __areas_ = __rhs.__areas_;
- return *this;
-}
-
-
-template<class _RealType>
-void
-piecewise_linear_distribution<_RealType>::param_type::__init()
-{
- __areas_.assign(__densities_.size() - 1, result_type());
- result_type _Sp = 0;
- for (size_t __i = 0; __i < __areas_.size(); ++__i)
- {
- __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
- (__b_[__i+1] - __b_[__i]) * .5;
- _Sp += __areas_[__i];
- }
- for (size_t __i = __areas_.size(); __i > 1;)
- {
- --__i;
- __areas_[__i] = __areas_[__i-1] / _Sp;
- }
- __areas_[0] = 0;
- for (size_t __i = 1; __i < __areas_.size(); ++__i)
- __areas_[__i] += __areas_[__i-1];
- for (size_t __i = 0; __i < __densities_.size(); ++__i)
- __densities_[__i] /= _Sp;
-}
-
-template<class _RealType>
-piecewise_linear_distribution<_RealType>::param_type::param_type()
- : __b_(2),
- __densities_(2, 1.0),
- __areas_(1, 0.0)
-{
- __b_[1] = 1;
-}
-
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
-piecewise_linear_distribution<_RealType>::param_type::param_type(
- _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
- : __b_(__fB, __lB)
-{
- if (__b_.size() < 2)
- {
- __b_.resize(2);
- __b_[0] = 0;
- __b_[1] = 1;
- __densities_.assign(2, 1.0);
- __areas_.assign(1, 0.0);
- }
- else
- {
- __densities_.reserve(__b_.size());
- for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
- __densities_.push_back(*__fW);
- __init();
- }
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _RealType>
-template<class _UnaryOperation>
-piecewise_linear_distribution<_RealType>::param_type::param_type(
- initializer_list<result_type> __bl, _UnaryOperation __fw)
- : __b_(__bl.begin(), __bl.end())
-{
- if (__b_.size() < 2)
- {
- __b_.resize(2);
- __b_[0] = 0;
- __b_[1] = 1;
- __densities_.assign(2, 1.0);
- __areas_.assign(1, 0.0);
- }
- else
- {
- __densities_.reserve(__b_.size());
- for (size_t __i = 0; __i < __b_.size(); ++__i)
- __densities_.push_back(__fw(__b_[__i]));
- __init();
- }
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-template<class _RealType>
-template<class _UnaryOperation>
-piecewise_linear_distribution<_RealType>::param_type::param_type(
- size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
- : __b_(__nw == 0 ? 2 : __nw + 1)
-{
- size_t __n = __b_.size() - 1;
- result_type __d = (__xmax - __xmin) / __n;
- __densities_.reserve(__b_.size());
- for (size_t __i = 0; __i < __n; ++__i)
- {
- __b_[__i] = __xmin + __i * __d;
- __densities_.push_back(__fw(__b_[__i]));
- }
- __b_[__n] = __xmax;
- __densities_.push_back(__fw(__b_[__n]));
- __init();
-}
-
-template<class _RealType>
-template<class _URNG>
-_RealType
-piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
- typedef uniform_real_distribution<result_type> _Gen;
- result_type __u = _Gen()(__g);
- ptr
diff _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 _CharT, class _Traits, class _RT>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
- const piecewise_linear_distribution<_RT>& __x)
-{
- __save_flags<_CharT, _Traits> __lx(__os);
- typedef basic_ostream<_CharT, _Traits> _OStream;
- __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
- _OStream::scientific);
- _CharT __sp = __os.widen(' ');
- __os.fill(__sp);
- size_t __n = __x.__p_.__b_.size();
- __os << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__b_[__i];
- __n = __x.__p_.__densities_.size();
- __os << __sp << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__densities_[__i];
- __n = __x.__p_.__areas_.size();
- __os << __sp << __n;
- for (size_t __i = 0; __i < __n; ++__i)
- __os << __sp << __x.__p_.__areas_[__i];
- return __os;
-}
-
-template <class _CharT, class _Traits, class _RT>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
- piecewise_linear_distribution<_RT>& __x)
-{
- typedef piecewise_linear_distribution<_RT> _Eng;
- typedef typename _Eng::result_type result_type;
- __save_flags<_CharT, _Traits> __lx(__is);
- typedef basic_istream<_CharT, _Traits> _Istream;
- __is.flags(_Istream::dec | _Istream::skipws);
- size_t __n;
- __is >> __n;
- vector<result_type> __b(__n);
- for (size_t __i = 0; __i < __n; ++__i)
- __is >> __b[__i];
- __is >> __n;
- vector<result_type> __densities(__n);
- for (size_t __i = 0; __i < __n; ++__i)
- __is >> __densities[__i];
- __is >> __n;
- vector<result_type> __areas(__n);
- for (size_t __i = 0; __i < __n; ++__i)
- __is >> __areas[__i];
- if (!__is.fail())
- {
- swap(__x.__p_.__b_, __b);
- swap(__x.__p_.__densities_, __densities);
- swap(__x.__p_.__areas_, __areas);
- }
- return __is;
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
#endif // _LIBCPP_RANDOM
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..f7bd7c108d535
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/bernoulli_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/bernoulli_distribution.h'}}
+#include <__random/bernoulli_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..813f81f6d9ec0
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/binomial_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/binomial_distribution.h'}}
+#include <__random/binomial_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..cf08b044db28e
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/cauchy_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/cauchy_distribution.h'}}
+#include <__random/cauchy_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..6905fc5103b30
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/chi_squared_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/chi_squared_distribution.h'}}
+#include <__random/chi_squared_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp
new file mode 100644
index 0000000000000..7d8d1c8dbcbc1
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/default_random_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/default_random_engine.h'}}
+#include <__random/default_random_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp
new file mode 100644
index 0000000000000..b11758a19950c
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/discard_block_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/discard_block_engine.h'}}
+#include <__random/discard_block_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..3720cfdb76a34
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/discrete_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/discrete_distribution.h'}}
+#include <__random/discrete_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..269f2440233b5
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/exponential_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/exponential_distribution.h'}}
+#include <__random/exponential_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..cb0c654c47880
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/extreme_value_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/extreme_value_distribution.h'}}
+#include <__random/extreme_value_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..9cb1399422588
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/fisher_f_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/fisher_f_distribution.h'}}
+#include <__random/fisher_f_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..89a931af819c5
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/gamma_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/gamma_distribution.h'}}
+#include <__random/gamma_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp
new file mode 100644
index 0000000000000..f471463c5220f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/generate_canonical.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/generate_canonical.h'}}
+#include <__random/generate_canonical.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..98891557e5cb1
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/geometric_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/geometric_distribution.h'}}
+#include <__random/geometric_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp
new file mode 100644
index 0000000000000..d413a81ae2e9f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/independent_bits_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/independent_bits_engine.h'}}
+#include <__random/independent_bits_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp
new file mode 100644
index 0000000000000..7977563430a76
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/is_seed_sequence.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/is_seed_sequence.h'}}
+#include <__random/is_seed_sequence.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp
new file mode 100644
index 0000000000000..de4898071eae7
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/knuth_b.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/knuth_b.h'}}
+#include <__random/knuth_b.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp
new file mode 100644
index 0000000000000..ca686e4aa000c
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/linear_congruential_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/linear_congruential_engine.h'}}
+#include <__random/linear_congruential_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp
new file mode 100644
index 0000000000000..c56c02f4add7f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/log2.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/log2.h'}}
+#include <__random/log2.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..fc4819e913864
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/lognormal_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/lognormal_distribution.h'}}
+#include <__random/lognormal_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp
new file mode 100644
index 0000000000000..36e3ef84355b3
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/mersenne_twister_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/mersenne_twister_engine.h'}}
+#include <__random/mersenne_twister_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..f3844cca1b1ee
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/negative_binomial_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/negative_binomial_distribution.h'}}
+#include <__random/negative_binomial_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..f1daa42c3e86f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/normal_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/normal_distribution.h'}}
+#include <__random/normal_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..34ab70808709d
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_constant_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/piecewise_constant_distribution.h'}}
+#include <__random/piecewise_constant_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..50c29b8fb96ad
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/piecewise_linear_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/piecewise_linear_distribution.h'}}
+#include <__random/piecewise_linear_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..70e84489feb30
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/poisson_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/poisson_distribution.h'}}
+#include <__random/poisson_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp
new file mode 100644
index 0000000000000..a4fd93e934e70
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/random_device.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/random_device.h'}}
+#include <__random/random_device.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp
new file mode 100644
index 0000000000000..225d7d4acc2f7
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/ranlux.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/ranlux.h'}}
+#include <__random/ranlux.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp
new file mode 100644
index 0000000000000..c08dddb0087c6
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/seed_seq.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/seed_seq.h'}}
+#include <__random/seed_seq.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp
new file mode 100644
index 0000000000000..0cc5fd56df697
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/shuffle_order_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/shuffle_order_engine.h'}}
+#include <__random/shuffle_order_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..3b08fc55b9417
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/student_t_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/student_t_distribution.h'}}
+#include <__random/student_t_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp
new file mode 100644
index 0000000000000..27a352a399fa8
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/subtract_with_carry_engine.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/subtract_with_carry_engine.h'}}
+#include <__random/subtract_with_carry_engine.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp
new file mode 100644
index 0000000000000..13cbe53da413f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_random_bit_generator.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/uniform_random_bit_generator.h'}}
+#include <__random/uniform_random_bit_generator.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..6ad314449ffc7
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/uniform_real_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/uniform_real_distribution.h'}}
+#include <__random/uniform_real_distribution.h>
diff --git a/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp b/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp
new file mode 100644
index 0000000000000..b1897147f159f
--- /dev/null
+++ b/libcxx/test/libcxx/diagnostics/detail.headers/random/weibull_distribution.module.verify.cpp
@@ -0,0 +1,15 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: modules-build
+
+// WARNING: This test was generated by 'generate_private_header_tests.py'
+// and should not be edited manually.
+
+// expected-error@*:* {{use of private header from outside its module: '__random/weibull_distribution.h'}}
+#include <__random/weibull_distribution.h>
diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp
index 5c6e7f7fd3b36..2f8bc7565e20e 100644
--- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp
+++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.lcong/params.fail.cpp
@@ -19,12 +19,12 @@ int main(int, char**)
{
typedef unsigned long long T;
- // expected-error at random:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
+ // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
std::linear_congruential_engine<T, 0, 0, 0> e2;
- // expected-error at random:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
+ // expected-error@*:* {{static_assert failed due to requirement '1ULL == 0 || 1ULL < 1ULL' "linear_congruential_engine invalid parameters"}}
std::linear_congruential_engine<T, 0, 1, 1> e3;
std::linear_congruential_engine<T, 1, 0, 1> e4;
- // expected-error at random:* {{static_assert failed due to requirement 'is_unsigned<int>::value' "_UIntType must be unsigned type"}}
+ // expected-error@*:* {{static_assert failed due to requirement 'is_unsigned<int>::value' "_UIntType must be unsigned type"}}
std::linear_congruential_engine<int, 0, 0, 0> e5;
return 0;
More information about the libcxx-commits
mailing list