1	// random number generation -*- C++ -*-
2
3	// Copyright (C) 2009-2023 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/**
26	* @file bits/random.h
27	* This is an internal header file, included by other library headers.
28	* Do not attempt to use it directly. @headername{random}
29	*/
30
31	#ifndef _RANDOM_H
32	#define _RANDOM_H 1
33
34	#include <vector>
35	#include <bits/uniform_int_dist.h>
36
37	namespace std _GLIBCXX_VISIBILITY(default)
38	{
39	_GLIBCXX_BEGIN_NAMESPACE_VERSION
40
41	// [26.4] Random number generation
42
43	/**
44	* @defgroup random Random Number Generation
45	* @ingroup numerics
46	*
47	* A facility for generating random numbers on selected distributions.
48	* @{
49	*/
50
51	// std::uniform_random_bit_generator is defined in <bits/uniform_int_dist.h>
52
53	/**
54	* @brief A function template for converting the output of a (integral)
55	* uniform random number generator to a floatng point result in the range
56	* [0-1).
57	*/
58	template<typename _RealType, size_t __bits,
59	typename _UniformRandomNumberGenerator>
60	_RealType
61	generate_canonical(_UniformRandomNumberGenerator& __g);
62
63	/// @cond undocumented
64	// Implementation-space details.
65	namespace __detail
66	{
67	template<typename _UIntType, size_t __w,
68	bool = __w < static_cast<size_t>
69	(std::numeric_limits<_UIntType>::digits)>
70	struct _Shift
71	{ static constexpr _UIntType __value = 0; };
72
73	template<typename _UIntType, size_t __w>
74	struct _Shift<_UIntType, __w, true>
75	{ static constexpr _UIntType __value = _UIntType(1) << __w; };
76
77	template<int __s,
78	int __which = ((__s <= __CHAR_BIT__ * sizeof (int))
79	+ (__s <= __CHAR_BIT__ * sizeof (long))
80	+ (__s <= __CHAR_BIT__ * sizeof (long long))
81	/* assume long long no bigger than __int128 */
82	+ (__s <= 128))>
83	struct _Select_uint_least_t
84	{
85	static_assert(__which < 0, /* needs to be dependent */
86	"sorry, would be too much trouble for a slow result");
87	};
88
89	template<int __s>
90	struct _Select_uint_least_t<__s, 4>
91	{ using type = unsigned int; };
92
93	template<int __s>
94	struct _Select_uint_least_t<__s, 3>
95	{ using type = unsigned long; };
96
97	template<int __s>
98	struct _Select_uint_least_t<__s, 2>
99	{ using type = unsigned long long; };
100
101	#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
102	template<int __s>
103	struct _Select_uint_least_t<__s, 1>
104	{ __extension__ using type = unsigned __int128; };
105	#endif
106
107	// Assume a != 0, a < m, c < m, x < m.
108	template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
109	bool __big_enough = (!(__m & (__m - 1))
110	|| (_Tp(-1) - __c) / __a >= __m - 1),
111	bool __schrage_ok = __m % __a < __m / __a>
112	struct _Mod
113	{
114	static _Tp
115	__calc(_Tp __x)
116	{
117	using _Tp2
118	= typename _Select_uint_least_t<std::__lg(__a)
119	+ std::__lg(__m) + 2>::type;
120	return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m);
121	}
122	};
123
124	// Schrage.
125	template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
126	struct _Mod<_Tp, __m, __a, __c, false, true>
127	{
128	static _Tp
129	__calc(_Tp __x);
130	};
131
132	// Special cases:
133	// - for m == 2^n or m == 0, unsigned integer overflow is safe.
134	// - a * (m - 1) + c fits in _Tp, there is no overflow.
135	template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
136	struct _Mod<_Tp, __m, __a, __c, true, __s>
137	{
138	static _Tp
139	__calc(_Tp __x)
140	{
141	_Tp __res = __a * __x + __c;
142	if (__m)
143	__res %= __m;
144	return __res;
145	}
146	};
147
148	template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
149	inline _Tp
150	__mod(_Tp __x)
151	{
152	if _GLIBCXX17_CONSTEXPR (__a == 0)
153	return __c;
154	else
155	{
156	// _Mod must not be instantiated with a == 0
157	constexpr _Tp __a1 = __a ? __a : 1;
158	return _Mod<_Tp, __m, __a1, __c>::__calc(__x);
159	}
160	}
161
162	/*
163	* An adaptor class for converting the output of any Generator into
164	* the input for a specific Distribution.
165	*/
166	template<typename _Engine, typename _DInputType>
167	struct _Adaptor
168	{
169	static_assert(std::is_floating_point<_DInputType>::value,
170	"template argument must be a floating point type");
171
172	public:
173	_Adaptor(_Engine& __g)
174	: _M_g(__g) { }
175
176	_DInputType
177	min() const
178	{ return _DInputType(0); }
179
180	_DInputType
181	max() const
182	{ return _DInputType(1); }
183
184	/*
185	* Converts a value generated by the adapted random number generator
186	* into a value in the input domain for the dependent random number
187	* distribution.
188	*/
189	_DInputType
190	operator()()
191	{
192	return std::generate_canonical<_DInputType,
193	std::numeric_limits<_DInputType>::digits,
194	_Engine>(_M_g);
195	}
196
197	private:
198	_Engine& _M_g;
199	};
200
201	// Detect whether a template argument _Sseq is a valid seed sequence for
202	// a random number engine _Engine with result type _Res.
203	// Used to constrain _Engine::_Engine(_Sseq&) and _Engine::seed(_Sseq&)
204	// as required by [rand.eng.general].
205
206	template<typename _Sseq>
207	using __seed_seq_generate_t = decltype(
208	std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
209	std::declval<uint_least32_t*>()));
210
211	template<typename _Sseq, typename _Engine, typename _Res,
212	typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
213	using _If_seed_seq_for = _Require<
214	__not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
215	is_unsigned<typename _Sseq::result_type>,
216	__not_<is_convertible<_Sseq, _Res>>
217	>;
218
219	} // namespace __detail
220	/// @endcond
221
222	/**
223	* @addtogroup random_generators Random Number Generators
224	* @ingroup random
225	*
226	* These classes define objects which provide random or pseudorandom
227	* numbers, either from a discrete or a continuous interval. The
228	* random number generator supplied as a part of this library are
229	* all uniform random number generators which provide a sequence of
230	* random number uniformly distributed over their range.
231	*
232	* A number generator is a function object with an operator() that
233	* takes zero arguments and returns a number.
234	*
235	* A compliant random number generator must satisfy the following
236	* requirements. <table border=1 cellpadding=10 cellspacing=0>
237	* <caption align=top>Random Number Generator Requirements</caption>
238	* <tr><td>To be documented.</td></tr> </table>
239	*
240	* @{
241	*/
242
243	/**
244	* @brief A model of a linear congruential random number generator.
245	*
246	* A random number generator that produces pseudorandom numbers via
247	* linear function:
248	* @f[
249	* x_{i+1}\leftarrow(ax_{i} + c) \bmod m
250	* @f]
251	*
252	* The template parameter @p _UIntType must be an unsigned integral type
253	* large enough to store values up to (__m-1). If the template parameter
254	* @p __m is 0, the modulus @p __m used is
255	* std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
256	* parameters @p __a and @p __c must be less than @p __m.
257	*
258	* The size of the state is @f$1@f$.
259	*
260	* @headerfile random
261	* @since C++11
262	*/
263	template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
264	class linear_congruential_engine
265	{
266	static_assert(std::is_unsigned<_UIntType>::value,
267	"result_type must be an unsigned integral type");
268	static_assert(__m == 0u || (__a < __m && __c < __m),
269	"template argument substituting __m out of bounds");
270
271	template<typename _Sseq>
272	using _If_seed_seq
273	= __detail::_If_seed_seq_for<_Sseq, linear_congruential_engine,
274	_UIntType>;
275
276	public:
277	/** The type of the generated random value. */
278	typedef _UIntType result_type;
279
280	/** The multiplier. */
281	static constexpr result_type multiplier = __a;
282	/** An increment. */
283	static constexpr result_type increment = __c;
284	/** The modulus. */
285	static constexpr result_type modulus = __m;
286	static constexpr result_type default_seed = 1u;
287
288	/**
289	* @brief Constructs a %linear_congruential_engine random number
290	* generator engine with seed 1.
291	*/
292	linear_congruential_engine() : linear_congruential_engine(default_seed)
293	{ }
294
295	/**
296	* @brief Constructs a %linear_congruential_engine random number
297	* generator engine with seed @p __s. The default seed value
298	* is 1.
299	*
300	* @param __s The initial seed value.
301	*/
302	explicit
303	linear_congruential_engine(result_type __s)
304	{ seed(__s); }
305
306	/**
307	* @brief Constructs a %linear_congruential_engine random number
308	* generator engine seeded from the seed sequence @p __q.
309	*
310	* @param __q the seed sequence.
311	*/
312	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
313	explicit
314	linear_congruential_engine(_Sseq& __q)
315	{ seed(__q); }
316
317	/**
318	* @brief Reseeds the %linear_congruential_engine random number generator
319	* engine sequence to the seed @p __s.
320	*
321	* @param __s The new seed.
322	*/
323	void
324	seed(result_type __s = default_seed);
325
326	/**
327	* @brief Reseeds the %linear_congruential_engine random number generator
328	* engine
329	* sequence using values from the seed sequence @p __q.
330	*
331	* @param __q the seed sequence.
332	*/
333	template<typename _Sseq>
334	_If_seed_seq<_Sseq>
335	seed(_Sseq& __q);
336
337	/**
338	* @brief Gets the smallest possible value in the output range.
339	*
340	* The minimum depends on the @p __c parameter: if it is zero, the
341	* minimum generated must be > 0, otherwise 0 is allowed.
342	*/
343	static constexpr result_type
344	min()
345	{ return __c == 0u ? 1u : 0u; }
346
347	/**
348	* @brief Gets the largest possible value in the output range.
349	*/
350	static constexpr result_type
351	max()
352	{ return __m - 1u; }
353
354	/**
355	* @brief Discard a sequence of random numbers.
356	*/
357	void
358	discard(unsigned long long __z)
359	{
360	for (; __z != 0ULL; --__z)
361	(*this)();
362	}
363
364	/**
365	* @brief Gets the next random number in the sequence.
366	*/
367	result_type
368	operator()()
369	{
370	_M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
371	return _M_x;
372	}
373
374	/**
375	* @brief Compares two linear congruential random number generator
376	* objects of the same type for equality.
377	*
378	* @param __lhs A linear congruential random number generator object.
379	* @param __rhs Another linear congruential random number generator
380	* object.
381	*
382	* @returns true if the infinite sequences of generated values
383	* would be equal, false otherwise.
384	*/
385	friend bool
386	operator==(const linear_congruential_engine& __lhs,
387	const linear_congruential_engine& __rhs)
388	{ return __lhs._M_x == __rhs._M_x; }
389
390	/**
391	* @brief Writes the textual representation of the state x(i) of x to
392	* @p __os.
393	*
394	* @param __os The output stream.
395	* @param __lcr A % linear_congruential_engine random number generator.
396	* @returns __os.
397	*/
398	template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
399	_UIntType1 __m1, typename _CharT, typename _Traits>
400	friend std::basic_ostream<_CharT, _Traits>&
401	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
402	const std::linear_congruential_engine<_UIntType1,
403	__a1, __c1, __m1>& __lcr);
404
405	/**
406	* @brief Sets the state of the engine by reading its textual
407	* representation from @p __is.
408	*
409	* The textual representation must have been previously written using
410	* an output stream whose imbued locale and whose type's template
411	* specialization arguments _CharT and _Traits were the same as those
412	* of @p __is.
413	*
414	* @param __is The input stream.
415	* @param __lcr A % linear_congruential_engine random number generator.
416	* @returns __is.
417	*/
418	template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
419	_UIntType1 __m1, typename _CharT, typename _Traits>
420	friend std::basic_istream<_CharT, _Traits>&
421	operator>>(std::basic_istream<_CharT, _Traits>& __is,
422	std::linear_congruential_engine<_UIntType1, __a1,
423	__c1, __m1>& __lcr);
424
425	private:
426	_UIntType _M_x;
427	};
428
429	#if __cpp_impl_three_way_comparison < 201907L
430	/**
431	* @brief Compares two linear congruential random number generator
432	* objects of the same type for inequality.
433	*
434	* @param __lhs A linear congruential random number generator object.
435	* @param __rhs Another linear congruential random number generator
436	* object.
437	*
438	* @returns true if the infinite sequences of generated values
439	* would be different, false otherwise.
440	*/
441	template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
442	inline bool
443	operator!=(const std::linear_congruential_engine<_UIntType, __a,
444	__c, __m>& __lhs,
445	const std::linear_congruential_engine<_UIntType, __a,
446	__c, __m>& __rhs)
447	{ return !(__lhs == __rhs); }
448	#endif
449
450	/**
451	* A generalized feedback shift register discrete random number generator.
452	*
453	* This algorithm avoids multiplication and division and is designed to be
454	* friendly to a pipelined architecture. If the parameters are chosen
455	* correctly, this generator will produce numbers with a very long period and
456	* fairly good apparent entropy, although still not cryptographically strong.
457	*
458	* The best way to use this generator is with the predefined mt19937 class.
459	*
460	* This algorithm was originally invented by Makoto Matsumoto and
461	* Takuji Nishimura.
462	*
463	* @tparam __w Word size, the number of bits in each element of
464	* the state vector.
465	* @tparam __n The degree of recursion.
466	* @tparam __m The period parameter.
467	* @tparam __r The separation point bit index.
468	* @tparam __a The last row of the twist matrix.
469	* @tparam __u The first right-shift tempering matrix parameter.
470	* @tparam __d The first right-shift tempering matrix mask.
471	* @tparam __s The first left-shift tempering matrix parameter.
472	* @tparam __b The first left-shift tempering matrix mask.
473	* @tparam __t The second left-shift tempering matrix parameter.
474	* @tparam __c The second left-shift tempering matrix mask.
475	* @tparam __l The second right-shift tempering matrix parameter.
476	* @tparam __f Initialization multiplier.
477	*
478	* @headerfile random
479	* @since C++11
480	*/
481	template<typename _UIntType, size_t __w,
482	size_t __n, size_t __m, size_t __r,
483	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
484	_UIntType __b, size_t __t,
485	_UIntType __c, size_t __l, _UIntType __f>
486	class mersenne_twister_engine
487	{
488	static_assert(std::is_unsigned<_UIntType>::value,
489	"result_type must be an unsigned integral type");
490	static_assert(1u <= __m && __m <= __n,
491	"template argument substituting __m out of bounds");
492	static_assert(__r <= __w, "template argument substituting "
493	"__r out of bound");
494	static_assert(__u <= __w, "template argument substituting "
495	"__u out of bound");
496	static_assert(__s <= __w, "template argument substituting "
497	"__s out of bound");
498	static_assert(__t <= __w, "template argument substituting "
499	"__t out of bound");
500	static_assert(__l <= __w, "template argument substituting "
501	"__l out of bound");
502	static_assert(__w <= std::numeric_limits<_UIntType>::digits,
503	"template argument substituting __w out of bound");
504	static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
505	"template argument substituting __a out of bound");
506	static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
507	"template argument substituting __b out of bound");
508	static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
509	"template argument substituting __c out of bound");
510	static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
511	"template argument substituting __d out of bound");
512	static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
513	"template argument substituting __f out of bound");
514
515	template<typename _Sseq>
516	using _If_seed_seq
517	= __detail::_If_seed_seq_for<_Sseq, mersenne_twister_engine,
518	_UIntType>;
519
520	public:
521	/** The type of the generated random value. */
522	typedef _UIntType result_type;
523
524	// parameter values
525	static constexpr size_t word_size = __w;
526	static constexpr size_t state_size = __n;
527	static constexpr size_t shift_size = __m;
528	static constexpr size_t mask_bits = __r;
529	static constexpr result_type xor_mask = __a;
530	static constexpr size_t tempering_u = __u;
531	static constexpr result_type tempering_d = __d;
532	static constexpr size_t tempering_s = __s;
533	static constexpr result_type tempering_b = __b;
534	static constexpr size_t tempering_t = __t;
535	static constexpr result_type tempering_c = __c;
536	static constexpr size_t tempering_l = __l;
537	static constexpr result_type initialization_multiplier = __f;
538	static constexpr result_type default_seed = 5489u;
539
540	// constructors and member functions
541
542	mersenne_twister_engine() : mersenne_twister_engine(default_seed) { }
543
544	explicit
545	mersenne_twister_engine(result_type __sd)
546	{ seed(__sd); }
547
548	/**
549	* @brief Constructs a %mersenne_twister_engine random number generator
550	* engine seeded from the seed sequence @p __q.
551	*
552	* @param __q the seed sequence.
553	*/
554	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
555	explicit
556	mersenne_twister_engine(_Sseq& __q)
557	{ seed(__q); }
558
559	void
560	seed(result_type __sd = default_seed);
561
562	template<typename _Sseq>
563	_If_seed_seq<_Sseq>
564	seed(_Sseq& __q);
565
566	/**
567	* @brief Gets the smallest possible value in the output range.
568	*/
569	static constexpr result_type
570	min()
571	{ return 0; }
572
573	/**
574	* @brief Gets the largest possible value in the output range.
575	*/
576	static constexpr result_type
577	max()
578	{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
579
580	/**
581	* @brief Discard a sequence of random numbers.
582	*/
583	void
584	discard(unsigned long long __z);
585
586	result_type
587	operator()();
588
589	/**
590	* @brief Compares two % mersenne_twister_engine random number generator
591	* objects of the same type for equality.
592	*
593	* @param __lhs A % mersenne_twister_engine random number generator
594	* object.
595	* @param __rhs Another % mersenne_twister_engine random number
596	* generator object.
597	*
598	* @returns true if the infinite sequences of generated values
599	* would be equal, false otherwise.
600	*/
601	friend bool
602	operator==(const mersenne_twister_engine& __lhs,
603	const mersenne_twister_engine& __rhs)
604	{ return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
605	&& __lhs._M_p == __rhs._M_p); }
606
607	/**
608	* @brief Inserts the current state of a % mersenne_twister_engine
609	* random number generator engine @p __x into the output stream
610	* @p __os.
611	*
612	* @param __os An output stream.
613	* @param __x A % mersenne_twister_engine random number generator
614	* engine.
615	*
616	* @returns The output stream with the state of @p __x inserted or in
617	* an error state.
618	*/
619	template<typename _UIntType1,
620	size_t __w1, size_t __n1,
621	size_t __m1, size_t __r1,
622	_UIntType1 __a1, size_t __u1,
623	_UIntType1 __d1, size_t __s1,
624	_UIntType1 __b1, size_t __t1,
625	_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
626	typename _CharT, typename _Traits>
627	friend std::basic_ostream<_CharT, _Traits>&
628	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
629	const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
630	__m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
631	__l1, __f1>& __x);
632
633	/**
634	* @brief Extracts the current state of a % mersenne_twister_engine
635	* random number generator engine @p __x from the input stream
636	* @p __is.
637	*
638	* @param __is An input stream.
639	* @param __x A % mersenne_twister_engine random number generator
640	* engine.
641	*
642	* @returns The input stream with the state of @p __x extracted or in
643	* an error state.
644	*/
645	template<typename _UIntType1,
646	size_t __w1, size_t __n1,
647	size_t __m1, size_t __r1,
648	_UIntType1 __a1, size_t __u1,
649	_UIntType1 __d1, size_t __s1,
650	_UIntType1 __b1, size_t __t1,
651	_UIntType1 __c1, size_t __l1, _UIntType1 __f1,
652	typename _CharT, typename _Traits>
653	friend std::basic_istream<_CharT, _Traits>&
654	operator>>(std::basic_istream<_CharT, _Traits>& __is,
655	std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
656	__r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
657	__l1, __f1>& __x);
658
659	private:
660	void _M_gen_rand();
661
662	_UIntType _M_x[state_size];
663	size_t _M_p;
664	};
665
666	#if __cpp_impl_three_way_comparison < 201907L
667	/**
668	* @brief Compares two % mersenne_twister_engine random number generator
669	* objects of the same type for inequality.
670	*
671	* @param __lhs A % mersenne_twister_engine random number generator
672	* object.
673	* @param __rhs Another % mersenne_twister_engine random number
674	* generator object.
675	*
676	* @returns true if the infinite sequences of generated values
677	* would be different, false otherwise.
678	*/
679	template<typename _UIntType, size_t __w,
680	size_t __n, size_t __m, size_t __r,
681	_UIntType __a, size_t __u, _UIntType __d, size_t __s,
682	_UIntType __b, size_t __t,
683	_UIntType __c, size_t __l, _UIntType __f>
684	inline bool
685	operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
686	__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
687	const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
688	__r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
689	{ return !(__lhs == __rhs); }
690	#endif
691
692	/**
693	* @brief The Marsaglia-Zaman generator.
694	*
695	* This is a model of a Generalized Fibonacci discrete random number
696	* generator, sometimes referred to as the SWC generator.
697	*
698	* A discrete random number generator that produces pseudorandom
699	* numbers using:
700	* @f[
701	* x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
702	* @f]
703	*
704	* The size of the state is @f$r@f$
705	* and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
706	*
707	* @headerfile random
708	* @since C++11
709	*/
710	template<typename _UIntType, size_t __w, size_t __s, size_t __r>
711	class subtract_with_carry_engine
712	{
713	static_assert(std::is_unsigned<_UIntType>::value,
714	"result_type must be an unsigned integral type");
715	static_assert(0u < __s && __s < __r,
716	"0 < s < r");
717	static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
718	"template argument substituting __w out of bounds");
719
720	template<typename _Sseq>
721	using _If_seed_seq
722	= __detail::_If_seed_seq_for<_Sseq, subtract_with_carry_engine,
723	_UIntType>;
724
725	public:
726	/** The type of the generated random value. */
727	typedef _UIntType result_type;
728
729	// parameter values
730	static constexpr size_t word_size = __w;
731	static constexpr size_t short_lag = __s;
732	static constexpr size_t long_lag = __r;
733	static constexpr uint_least32_t default_seed = 19780503u;
734
735	subtract_with_carry_engine() : subtract_with_carry_engine(0u)
736	{ }
737
738	/**
739	* @brief Constructs an explicitly seeded %subtract_with_carry_engine
740	* random number generator.
741	*/
742	explicit
743	subtract_with_carry_engine(result_type __sd)
744	{ seed(__sd); }
745
746	/**
747	* @brief Constructs a %subtract_with_carry_engine random number engine
748	* seeded from the seed sequence @p __q.
749	*
750	* @param __q the seed sequence.
751	*/
752	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
753	explicit
754	subtract_with_carry_engine(_Sseq& __q)
755	{ seed(__q); }
756
757	/**
758	* @brief Seeds the initial state @f$x_0@f$ of the random number
759	* generator.
760	*
761	* N1688[4.19] modifies this as follows. If @p __value == 0,
762	* sets value to 19780503. In any case, with a linear
763	* congruential generator lcg(i) having parameters @f$ m_{lcg} =
764	* 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
765	* @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
766	* \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$
767	* set carry to 1, otherwise sets carry to 0.
768	*/
769	void
770	seed(result_type __sd = 0u);
771
772	/**
773	* @brief Seeds the initial state @f$x_0@f$ of the
774	* % subtract_with_carry_engine random number generator.
775	*/
776	template<typename _Sseq>
777	_If_seed_seq<_Sseq>
778	seed(_Sseq& __q);
779
780	/**
781	* @brief Gets the inclusive minimum value of the range of random
782	* integers returned by this generator.
783	*/
784	static constexpr result_type
785	min()
786	{ return 0; }
787
788	/**
789	* @brief Gets the inclusive maximum value of the range of random
790	* integers returned by this generator.
791	*/
792	static constexpr result_type
793	max()
794	{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
795
796	/**
797	* @brief Discard a sequence of random numbers.
798	*/
799	void
800	discard(unsigned long long __z)
801	{
802	for (; __z != 0ULL; --__z)
803	(*this)();
804	}
805
806	/**
807	* @brief Gets the next random number in the sequence.
808	*/
809	result_type
810	operator()();
811
812	/**
813	* @brief Compares two % subtract_with_carry_engine random number
814	* generator objects of the same type for equality.
815	*
816	* @param __lhs A % subtract_with_carry_engine random number generator
817	* object.
818	* @param __rhs Another % subtract_with_carry_engine random number
819	* generator object.
820	*
821	* @returns true if the infinite sequences of generated values
822	* would be equal, false otherwise.
823	*/
824	friend bool
825	operator==(const subtract_with_carry_engine& __lhs,
826	const subtract_with_carry_engine& __rhs)
827	{ return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
828	&& __lhs._M_carry == __rhs._M_carry
829	&& __lhs._M_p == __rhs._M_p); }
830
831	/**
832	* @brief Inserts the current state of a % subtract_with_carry_engine
833	* random number generator engine @p __x into the output stream
834	* @p __os.
835	*
836	* @param __os An output stream.
837	* @param __x A % subtract_with_carry_engine random number generator
838	* engine.
839	*
840	* @returns The output stream with the state of @p __x inserted or in
841	* an error state.
842	*/
843	template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
844	typename _CharT, typename _Traits>
845	friend std::basic_ostream<_CharT, _Traits>&
846	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
847	const std::subtract_with_carry_engine<_UIntType1, __w1,
848	__s1, __r1>& __x);
849
850	/**
851	* @brief Extracts the current state of a % subtract_with_carry_engine
852	* random number generator engine @p __x from the input stream
853	* @p __is.
854	*
855	* @param __is An input stream.
856	* @param __x A % subtract_with_carry_engine random number generator
857	* engine.
858	*
859	* @returns The input stream with the state of @p __x extracted or in
860	* an error state.
861	*/
862	template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
863	typename _CharT, typename _Traits>
864	friend std::basic_istream<_CharT, _Traits>&
865	operator>>(std::basic_istream<_CharT, _Traits>& __is,
866	std::subtract_with_carry_engine<_UIntType1, __w1,
867	__s1, __r1>& __x);
868
869	private:
870	/// The state of the generator. This is a ring buffer.
871	_UIntType _M_x[long_lag];
872	_UIntType _M_carry; ///< The carry
873	size_t _M_p; ///< Current index of x(i - r).
874	};
875
876	#if __cpp_impl_three_way_comparison < 201907L
877	/**
878	* @brief Compares two % subtract_with_carry_engine random number
879	* generator objects of the same type for inequality.
880	*
881	* @param __lhs A % subtract_with_carry_engine random number generator
882	* object.
883	* @param __rhs Another % subtract_with_carry_engine random number
884	* generator object.
885	*
886	* @returns true if the infinite sequences of generated values
887	* would be different, false otherwise.
888	*/
889	template<typename _UIntType, size_t __w, size_t __s, size_t __r>
890	inline bool
891	operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
892	__s, __r>& __lhs,
893	const std::subtract_with_carry_engine<_UIntType, __w,
894	__s, __r>& __rhs)
895	{ return !(__lhs == __rhs); }
896	#endif
897
898	/**
899	* Produces random numbers from some base engine by discarding blocks of
900	* data.
901	*
902	* @pre @f$ 0 \leq r \leq p @f$
903	*
904	* @headerfile random
905	* @since C++11
906	*/
907	template<typename _RandomNumberEngine, size_t __p, size_t __r>
908	class discard_block_engine
909	{
910	static_assert(1 <= __r && __r <= __p,
911	"template argument substituting __r out of bounds");
912
913	public:
914	/** The type of the generated random value. */
915	typedef typename _RandomNumberEngine::result_type result_type;
916
917	template<typename _Sseq>
918	using _If_seed_seq
919	= __detail::_If_seed_seq_for<_Sseq, discard_block_engine,
920	result_type>;
921
922	// parameter values
923	static constexpr size_t block_size = __p;
924	static constexpr size_t used_block = __r;
925
926	/**
927	* @brief Constructs a default %discard_block_engine engine.
928	*
929	* The underlying engine is default constructed as well.
930	*/
931	discard_block_engine()
932	: _M_b(), _M_n(0) { }
933
934	/**
935	* @brief Copy constructs a %discard_block_engine engine.
936	*
937	* Copies an existing base class random number generator.
938	* @param __rng An existing (base class) engine object.
939	*/
940	explicit
941	discard_block_engine(const _RandomNumberEngine& __rng)
942	: _M_b(__rng), _M_n(0) { }
943
944	/**
945	* @brief Move constructs a %discard_block_engine engine.
946	*
947	* Copies an existing base class random number generator.
948	* @param __rng An existing (base class) engine object.
949	*/
950	explicit
951	discard_block_engine(_RandomNumberEngine&& __rng)
952	: _M_b(std::move(__rng)), _M_n(0) { }
953
954	/**
955	* @brief Seed constructs a %discard_block_engine engine.
956	*
957	* Constructs the underlying generator engine seeded with @p __s.
958	* @param __s A seed value for the base class engine.
959	*/
960	explicit
961	discard_block_engine(result_type __s)
962	: _M_b(__s), _M_n(0) { }
963
964	/**
965	* @brief Generator construct a %discard_block_engine engine.
966	*
967	* @param __q A seed sequence.
968	*/
969	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
970	explicit
971	discard_block_engine(_Sseq& __q)
972	: _M_b(__q), _M_n(0)
973	{ }
974
975	/**
976	* @brief Reseeds the %discard_block_engine object with the default
977	* seed for the underlying base class generator engine.
978	*/
979	void
980	seed()
981	{
982	_M_b.seed();
983	_M_n = 0;
984	}
985
986	/**
987	* @brief Reseeds the %discard_block_engine object with the default
988	* seed for the underlying base class generator engine.
989	*/
990	void
991	seed(result_type __s)
992	{
993	_M_b.seed(__s);
994	_M_n = 0;
995	}
996
997	/**
998	* @brief Reseeds the %discard_block_engine object with the given seed
999	* sequence.
1000	* @param __q A seed generator function.
1001	*/
1002	template<typename _Sseq>
1003	_If_seed_seq<_Sseq>
1004	seed(_Sseq& __q)
1005	{
1006	_M_b.seed(__q);
1007	_M_n = 0;
1008	}
1009
1010	/**
1011	* @brief Gets a const reference to the underlying generator engine
1012	* object.
1013	*/
1014	const _RandomNumberEngine&
1015	base() const noexcept
1016	{ return _M_b; }
1017
1018	/**
1019	* @brief Gets the minimum value in the generated random number range.
1020	*/
1021	static constexpr result_type
1022	min()
1023	{ return _RandomNumberEngine::min(); }
1024
1025	/**
1026	* @brief Gets the maximum value in the generated random number range.
1027	*/
1028	static constexpr result_type
1029	max()
1030	{ return _RandomNumberEngine::max(); }
1031
1032	/**
1033	* @brief Discard a sequence of random numbers.
1034	*/
1035	void
1036	discard(unsigned long long __z)
1037	{
1038	for (; __z != 0ULL; --__z)
1039	(*this)();
1040	}
1041
1042	/**
1043	* @brief Gets the next value in the generated random number sequence.
1044	*/
1045	result_type
1046	operator()();
1047
1048	/**
1049	* @brief Compares two %discard_block_engine random number generator
1050	* objects of the same type for equality.
1051	*
1052	* @param __lhs A %discard_block_engine random number generator object.
1053	* @param __rhs Another %discard_block_engine random number generator
1054	* object.
1055	*
1056	* @returns true if the infinite sequences of generated values
1057	* would be equal, false otherwise.
1058	*/
1059	friend bool
1060	operator==(const discard_block_engine& __lhs,
1061	const discard_block_engine& __rhs)
1062	{ return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1063
1064	/**
1065	* @brief Inserts the current state of a %discard_block_engine random
1066	* number generator engine @p __x into the output stream
1067	* @p __os.
1068	*
1069	* @param __os An output stream.
1070	* @param __x A %discard_block_engine random number generator engine.
1071	*
1072	* @returns The output stream with the state of @p __x inserted or in
1073	* an error state.
1074	*/
1075	template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1076	typename _CharT, typename _Traits>
1077	friend std::basic_ostream<_CharT, _Traits>&
1078	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1079	const std::discard_block_engine<_RandomNumberEngine1,
1080	__p1, __r1>& __x);
1081
1082	/**
1083	* @brief Extracts the current state of a % subtract_with_carry_engine
1084	* random number generator engine @p __x from the input stream
1085	* @p __is.
1086	*
1087	* @param __is An input stream.
1088	* @param __x A %discard_block_engine random number generator engine.
1089	*
1090	* @returns The input stream with the state of @p __x extracted or in
1091	* an error state.
1092	*/
1093	template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1094	typename _CharT, typename _Traits>
1095	friend std::basic_istream<_CharT, _Traits>&
1096	operator>>(std::basic_istream<_CharT, _Traits>& __is,
1097	std::discard_block_engine<_RandomNumberEngine1,
1098	__p1, __r1>& __x);
1099
1100	private:
1101	_RandomNumberEngine _M_b;
1102	size_t _M_n;
1103	};
1104
1105	#if __cpp_impl_three_way_comparison < 201907L
1106	/**
1107	* @brief Compares two %discard_block_engine random number generator
1108	* objects of the same type for inequality.
1109	*
1110	* @param __lhs A %discard_block_engine random number generator object.
1111	* @param __rhs Another %discard_block_engine random number generator
1112	* object.
1113	*
1114	* @returns true if the infinite sequences of generated values
1115	* would be different, false otherwise.
1116	*/
1117	template<typename _RandomNumberEngine, size_t __p, size_t __r>
1118	inline bool
1119	operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
1120	__r>& __lhs,
1121	const std::discard_block_engine<_RandomNumberEngine, __p,
1122	__r>& __rhs)
1123	{ return !(__lhs == __rhs); }
1124	#endif
1125
1126	/**
1127	* Produces random numbers by combining random numbers from some base
1128	* engine to produce random numbers with a specified number of bits @p __w.
1129	*
1130	* @headerfile random
1131	* @since C++11
1132	*/
1133	template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1134	class independent_bits_engine
1135	{
1136	static_assert(std::is_unsigned<_UIntType>::value,
1137	"result_type must be an unsigned integral type");
1138	static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
1139	"template argument substituting __w out of bounds");
1140
1141	template<typename _Sseq>
1142	using _If_seed_seq
1143	= __detail::_If_seed_seq_for<_Sseq, independent_bits_engine,
1144	_UIntType>;
1145
1146	public:
1147	/** The type of the generated random value. */
1148	typedef _UIntType result_type;
1149
1150	/**
1151	* @brief Constructs a default %independent_bits_engine engine.
1152	*
1153	* The underlying engine is default constructed as well.
1154	*/
1155	independent_bits_engine()
1156	: _M_b() { }
1157
1158	/**
1159	* @brief Copy constructs a %independent_bits_engine engine.
1160	*
1161	* Copies an existing base class random number generator.
1162	* @param __rng An existing (base class) engine object.
1163	*/
1164	explicit
1165	independent_bits_engine(const _RandomNumberEngine& __rng)
1166	: _M_b(__rng) { }
1167
1168	/**
1169	* @brief Move constructs a %independent_bits_engine engine.
1170	*
1171	* Copies an existing base class random number generator.
1172	* @param __rng An existing (base class) engine object.
1173	*/
1174	explicit
1175	independent_bits_engine(_RandomNumberEngine&& __rng)
1176	: _M_b(std::move(__rng)) { }
1177
1178	/**
1179	* @brief Seed constructs a %independent_bits_engine engine.
1180	*
1181	* Constructs the underlying generator engine seeded with @p __s.
1182	* @param __s A seed value for the base class engine.
1183	*/
1184	explicit
1185	independent_bits_engine(result_type __s)
1186	: _M_b(__s) { }
1187
1188	/**
1189	* @brief Generator construct a %independent_bits_engine engine.
1190	*
1191	* @param __q A seed sequence.
1192	*/
1193	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1194	explicit
1195	independent_bits_engine(_Sseq& __q)
1196	: _M_b(__q)
1197	{ }
1198
1199	/**
1200	* @brief Reseeds the %independent_bits_engine object with the default
1201	* seed for the underlying base class generator engine.
1202	*/
1203	void
1204	seed()
1205	{ _M_b.seed(); }
1206
1207	/**
1208	* @brief Reseeds the %independent_bits_engine object with the default
1209	* seed for the underlying base class generator engine.
1210	*/
1211	void
1212	seed(result_type __s)
1213	{ _M_b.seed(__s); }
1214
1215	/**
1216	* @brief Reseeds the %independent_bits_engine object with the given
1217	* seed sequence.
1218	* @param __q A seed generator function.
1219	*/
1220	template<typename _Sseq>
1221	_If_seed_seq<_Sseq>
1222	seed(_Sseq& __q)
1223	{ _M_b.seed(__q); }
1224
1225	/**
1226	* @brief Gets a const reference to the underlying generator engine
1227	* object.
1228	*/
1229	const _RandomNumberEngine&
1230	base() const noexcept
1231	{ return _M_b; }
1232
1233	/**
1234	* @brief Gets the minimum value in the generated random number range.
1235	*/
1236	static constexpr result_type
1237	min()
1238	{ return 0U; }
1239
1240	/**
1241	* @brief Gets the maximum value in the generated random number range.
1242	*/
1243	static constexpr result_type
1244	max()
1245	{ return __detail::_Shift<_UIntType, __w>::__value - 1; }
1246
1247	/**
1248	* @brief Discard a sequence of random numbers.
1249	*/
1250	void
1251	discard(unsigned long long __z)
1252	{
1253	for (; __z != 0ULL; --__z)
1254	(*this)();
1255	}
1256
1257	/**
1258	* @brief Gets the next value in the generated random number sequence.
1259	*/
1260	result_type
1261	operator()();
1262
1263	/**
1264	* @brief Compares two %independent_bits_engine random number generator
1265	* objects of the same type for equality.
1266	*
1267	* @param __lhs A %independent_bits_engine random number generator
1268	* object.
1269	* @param __rhs Another %independent_bits_engine random number generator
1270	* object.
1271	*
1272	* @returns true if the infinite sequences of generated values
1273	* would be equal, false otherwise.
1274	*/
1275	friend bool
1276	operator==(const independent_bits_engine& __lhs,
1277	const independent_bits_engine& __rhs)
1278	{ return __lhs._M_b == __rhs._M_b; }
1279
1280	/**
1281	* @brief Extracts the current state of a % subtract_with_carry_engine
1282	* random number generator engine @p __x from the input stream
1283	* @p __is.
1284	*
1285	* @param __is An input stream.
1286	* @param __x A %independent_bits_engine random number generator
1287	* engine.
1288	*
1289	* @returns The input stream with the state of @p __x extracted or in
1290	* an error state.
1291	*/
1292	template<typename _CharT, typename _Traits>
1293	friend std::basic_istream<_CharT, _Traits>&
1294	operator>>(std::basic_istream<_CharT, _Traits>& __is,
1295	std::independent_bits_engine<_RandomNumberEngine,
1296	__w, _UIntType>& __x)
1297	{
1298	__is >> __x._M_b;
1299	return __is;
1300	}
1301
1302	private:
1303	_RandomNumberEngine _M_b;
1304	};
1305
1306	#if __cpp_impl_three_way_comparison < 201907L
1307	/**
1308	* @brief Compares two %independent_bits_engine random number generator
1309	* objects of the same type for inequality.
1310	*
1311	* @param __lhs A %independent_bits_engine random number generator
1312	* object.
1313	* @param __rhs Another %independent_bits_engine random number generator
1314	* object.
1315	*
1316	* @returns true if the infinite sequences of generated values
1317	* would be different, false otherwise.
1318	*/
1319	template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1320	inline bool
1321	operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
1322	_UIntType>& __lhs,
1323	const std::independent_bits_engine<_RandomNumberEngine, __w,
1324	_UIntType>& __rhs)
1325	{ return !(__lhs == __rhs); }
1326	#endif
1327
1328	/**
1329	* @brief Inserts the current state of a %independent_bits_engine random
1330	* number generator engine @p __x into the output stream @p __os.
1331	*
1332	* @param __os An output stream.
1333	* @param __x A %independent_bits_engine random number generator engine.
1334	*
1335	* @returns The output stream with the state of @p __x inserted or in
1336	* an error state.
1337	*/
1338	template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
1339	typename _CharT, typename _Traits>
1340	std::basic_ostream<_CharT, _Traits>&
1341	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1342	const std::independent_bits_engine<_RandomNumberEngine,
1343	__w, _UIntType>& __x)
1344	{
1345	__os << __x.base();
1346	return __os;
1347	}
1348
1349
1350	/**
1351	* @brief Produces random numbers by reordering random numbers from some
1352	* base engine.
1353	*
1354	* The values from the base engine are stored in a sequence of size @p __k
1355	* and shuffled by an algorithm that depends on those values.
1356	*
1357	* @headerfile random
1358	* @since C++11
1359	*/
1360	template<typename _RandomNumberEngine, size_t __k>
1361	class shuffle_order_engine
1362	{
1363	static_assert(1u <= __k, "template argument substituting "
1364	"__k out of bound");
1365
1366	public:
1367	/** The type of the generated random value. */
1368	typedef typename _RandomNumberEngine::result_type result_type;
1369
1370	template<typename _Sseq>
1371	using _If_seed_seq
1372	= __detail::_If_seed_seq_for<_Sseq, shuffle_order_engine,
1373	result_type>;
1374
1375	static constexpr size_t table_size = __k;
1376
1377	/**
1378	* @brief Constructs a default %shuffle_order_engine engine.
1379	*
1380	* The underlying engine is default constructed as well.
1381	*/
1382	shuffle_order_engine()
1383	: _M_b()
1384	{ _M_initialize(); }
1385
1386	/**
1387	* @brief Copy constructs a %shuffle_order_engine engine.
1388	*
1389	* Copies an existing base class random number generator.
1390	* @param __rng An existing (base class) engine object.
1391	*/
1392	explicit
1393	shuffle_order_engine(const _RandomNumberEngine& __rng)
1394	: _M_b(__rng)
1395	{ _M_initialize(); }
1396
1397	/**
1398	* @brief Move constructs a %shuffle_order_engine engine.
1399	*
1400	* Copies an existing base class random number generator.
1401	* @param __rng An existing (base class) engine object.
1402	*/
1403	explicit
1404	shuffle_order_engine(_RandomNumberEngine&& __rng)
1405	: _M_b(std::move(__rng))
1406	{ _M_initialize(); }
1407
1408	/**
1409	* @brief Seed constructs a %shuffle_order_engine engine.
1410	*
1411	* Constructs the underlying generator engine seeded with @p __s.
1412	* @param __s A seed value for the base class engine.
1413	*/
1414	explicit
1415	shuffle_order_engine(result_type __s)
1416	: _M_b(__s)
1417	{ _M_initialize(); }
1418
1419	/**
1420	* @brief Generator construct a %shuffle_order_engine engine.
1421	*
1422	* @param __q A seed sequence.
1423	*/
1424	template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1425	explicit
1426	shuffle_order_engine(_Sseq& __q)
1427	: _M_b(__q)
1428	{ _M_initialize(); }
1429
1430	/**
1431	* @brief Reseeds the %shuffle_order_engine object with the default seed
1432	for the underlying base class generator engine.
1433	*/
1434	void
1435	seed()
1436	{
1437	_M_b.seed();
1438	_M_initialize();
1439	}
1440
1441	/**
1442	* @brief Reseeds the %shuffle_order_engine object with the default seed
1443	* for the underlying base class generator engine.
1444	*/
1445	void
1446	seed(result_type __s)
1447	{
1448	_M_b.seed(__s);
1449	_M_initialize();
1450	}
1451
1452	/**
1453	* @brief Reseeds the %shuffle_order_engine object with the given seed
1454	* sequence.
1455	* @param __q A seed generator function.
1456	*/
1457	template<typename _Sseq>
1458	_If_seed_seq<_Sseq>
1459	seed(_Sseq& __q)
1460	{
1461	_M_b.seed(__q);
1462	_M_initialize();
1463	}
1464
1465	/**
1466	* Gets a const reference to the underlying generator engine object.
1467	*/
1468	const _RandomNumberEngine&
1469	base() const noexcept
1470	{ return _M_b; }
1471
1472	/**
1473	* Gets the minimum value in the generated random number range.
1474	*/
1475	static constexpr result_type
1476	min()
1477	{ return _RandomNumberEngine::min(); }
1478
1479	/**
1480	* Gets the maximum value in the generated random number range.
1481	*/
1482	static constexpr result_type
1483	max()
1484	{ return _RandomNumberEngine::max(); }
1485
1486	/**
1487	* Discard a sequence of random numbers.
1488	*/
1489	void
1490	discard(unsigned long long __z)
1491	{
1492	for (; __z != 0ULL; --__z)
1493	(*this)();
1494	}
1495
1496	/**
1497	* Gets the next value in the generated random number sequence.
1498	*/
1499	result_type
1500	operator()();
1501
1502	/**
1503	* Compares two %shuffle_order_engine random number generator objects
1504	* of the same type for equality.
1505	*
1506	* @param __lhs A %shuffle_order_engine random number generator object.
1507	* @param __rhs Another %shuffle_order_engine random number generator
1508	* object.
1509	*
1510	* @returns true if the infinite sequences of generated values
1511	* would be equal, false otherwise.
1512	*/
1513	friend bool
1514	operator==(const shuffle_order_engine& __lhs,
1515	const shuffle_order_engine& __rhs)
1516	{ return (__lhs._M_b == __rhs._M_b
1517	&& std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1518	&& __lhs._M_y == __rhs._M_y); }
1519
1520	/**
1521	* @brief Inserts the current state of a %shuffle_order_engine random
1522	* number generator engine @p __x into the output stream
1523	@p __os.
1524	*
1525	* @param __os An output stream.
1526	* @param __x A %shuffle_order_engine random number generator engine.
1527	*
1528	* @returns The output stream with the state of @p __x inserted or in
1529	* an error state.
1530	*/
1531	template<typename _RandomNumberEngine1, size_t __k1,
1532	typename _CharT, typename _Traits>
1533	friend std::basic_ostream<_CharT, _Traits>&
1534	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1535	const std::shuffle_order_engine<_RandomNumberEngine1,
1536	__k1>& __x);
1537
1538	/**
1539	* @brief Extracts the current state of a % subtract_with_carry_engine
1540	* random number generator engine @p __x from the input stream
1541	* @p __is.
1542	*
1543	* @param __is An input stream.
1544	* @param __x A %shuffle_order_engine random number generator engine.
1545	*
1546	* @returns The input stream with the state of @p __x extracted or in
1547	* an error state.
1548	*/
1549	template<typename _RandomNumberEngine1, size_t __k1,
1550	typename _CharT, typename _Traits>
1551	friend std::basic_istream<_CharT, _Traits>&
1552	operator>>(std::basic_istream<_CharT, _Traits>& __is,
1553	std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
1554
1555	private:
1556	void _M_initialize()
1557	{
1558	for (size_t __i = 0; __i < __k; ++__i)
1559	_M_v[__i] = _M_b();
1560	_M_y = _M_b();
1561	}
1562
1563	_RandomNumberEngine _M_b;
1564	result_type _M_v[__k];
1565	result_type _M_y;
1566	};
1567
1568	#if __cpp_impl_three_way_comparison < 201907L
1569	/**
1570	* Compares two %shuffle_order_engine random number generator objects
1571	* of the same type for inequality.
1572	*
1573	* @param __lhs A %shuffle_order_engine random number generator object.
1574	* @param __rhs Another %shuffle_order_engine random number generator
1575	* object.
1576	*
1577	* @returns true if the infinite sequences of generated values
1578	* would be different, false otherwise.
1579	*/
1580	template<typename _RandomNumberEngine, size_t __k>
1581	inline bool
1582	operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
1583	__k>& __lhs,
1584	const std::shuffle_order_engine<_RandomNumberEngine,
1585	__k>& __rhs)
1586	{ return !(__lhs == __rhs); }
1587	#endif
1588
1589	/**
1590	* The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
1591	*/
1592	typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1593	minstd_rand0;
1594
1595	/**
1596	* An alternative LCR (Lehmer Generator function).
1597	*/
1598	typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
1599	minstd_rand;
1600
1601	/**
1602	* The classic Mersenne Twister.
1603	*
1604	* Reference:
1605	* M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
1606	* Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
1607	* on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
1608	*/
1609	typedef mersenne_twister_engine<
1610	uint_fast32_t,
1611	32, 624, 397, 31,
1612	0x9908b0dfUL, 11,
1613	0xffffffffUL, 7,
1614	0x9d2c5680UL, 15,
1615	0xefc60000UL, 18, 1812433253UL> mt19937;
1616
1617	/**
1618	* An alternative Mersenne Twister.
1619	*/
1620	typedef mersenne_twister_engine<
1621	uint_fast64_t,
1622	64, 312, 156, 31,
1623	0xb5026f5aa96619e9ULL, 29,
1624	0x5555555555555555ULL, 17,
1625	0x71d67fffeda60000ULL, 37,
1626	0xfff7eee000000000ULL, 43,
1627	6364136223846793005ULL> mt19937_64;
1628
1629	typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
1630	ranlux24_base;
1631
1632	typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
1633	ranlux48_base;
1634
1635	typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
1636
1637	typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
1638
1639	typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
1640
1641	typedef minstd_rand0 default_random_engine;
1642
1643	/**
1644	* A standard interface to a platform-specific non-deterministic
1645	* random number generator (if any are available).
1646	*
1647	* @headerfile random
1648	* @since C++11
1649	*/
1650	class random_device
1651	{
1652	public:
1653	/** The type of the generated random value. */
1654	typedef unsigned int result_type;
1655
1656	// constructors, destructors and member functions
1657
1658	random_device() { _M_init(token: "default"); }
1659
1660	explicit
1661	random_device(const std::string& __token) { _M_init(__token); }
1662
1663	~random_device()
1664	{ _M_fini(); }
1665
1666	static constexpr result_type
1667	min()
1668	{ return std::numeric_limits<result_type>::min(); }
1669
1670	static constexpr result_type
1671	max()
1672	{ return std::numeric_limits<result_type>::max(); }
1673
1674	double
1675	entropy() const noexcept
1676	{ return this->_M_getentropy(); }
1677
1678	result_type
1679	operator()()
1680	{ return this->_M_getval(); }
1681
1682	// No copy functions.
1683	random_device(const random_device&) = delete;
1684	void operator=(const random_device&) = delete;
1685
1686	private:
1687
1688	void _M_init(const std::string& __token);
1689	void _M_init_pretr1(const std::string& __token);
1690	void _M_fini();
1691
1692	result_type _M_getval();
1693	result_type _M_getval_pretr1();
1694	double _M_getentropy() const noexcept;
1695
1696	void _M_init(const char*, size_t); // not exported from the shared library
1697
1698	__extension__ union
1699	{
1700	struct
1701	{
1702	void* _M_file;
1703	result_type (*_M_func)(void*);
1704	int _M_fd;
1705	};
1706	mt19937 _M_mt;
1707	};
1708	};
1709
1710	/// @} group random_generators
1711
1712	/**
1713	* @addtogroup random_distributions Random Number Distributions
1714	* @ingroup random
1715	* @{
1716	*/
1717
1718	/**
1719	* @addtogroup random_distributions_uniform Uniform Distributions
1720	* @ingroup random_distributions
1721	* @{
1722	*/
1723
1724	// std::uniform_int_distribution is defined in <bits/uniform_int_dist.h>
1725
1726	#if __cpp_impl_three_way_comparison < 201907L
1727	/**
1728	* @brief Return true if two uniform integer distributions have
1729	* different parameters.
1730	*/
1731	template<typename _IntType>
1732	inline bool
1733	operator!=(const std::uniform_int_distribution<_IntType>& __d1,
1734	const std::uniform_int_distribution<_IntType>& __d2)
1735	{ return !(__d1 == __d2); }
1736	#endif
1737
1738	/**
1739	* @brief Inserts a %uniform_int_distribution random number
1740	* distribution @p __x into the output stream @p os.
1741	*
1742	* @param __os An output stream.
1743	* @param __x A %uniform_int_distribution random number distribution.
1744	*
1745	* @returns The output stream with the state of @p __x inserted or in
1746	* an error state.
1747	*/
1748	template<typename _IntType, typename _CharT, typename _Traits>
1749	std::basic_ostream<_CharT, _Traits>&
1750	operator<<(std::basic_ostream<_CharT, _Traits>&,
1751	const std::uniform_int_distribution<_IntType>&);
1752
1753	/**
1754	* @brief Extracts a %uniform_int_distribution random number distribution
1755	* @p __x from the input stream @p __is.
1756	*
1757	* @param __is An input stream.
1758	* @param __x A %uniform_int_distribution random number generator engine.
1759	*
1760	* @returns The input stream with @p __x extracted or in an error state.
1761	*/
1762	template<typename _IntType, typename _CharT, typename _Traits>
1763	std::basic_istream<_CharT, _Traits>&
1764	operator>>(std::basic_istream<_CharT, _Traits>&,
1765	std::uniform_int_distribution<_IntType>&);
1766
1767
1768	/**
1769	* @brief Uniform continuous distribution for random numbers.
1770	*
1771	* A continuous random distribution on the range [min, max) with equal
1772	* probability throughout the range. The URNG should be real-valued and
1773	* deliver number in the range [0, 1).
1774	*
1775	* @headerfile random
1776	* @since C++11
1777	*/
1778	template<typename _RealType = double>
1779	class uniform_real_distribution
1780	{
1781	static_assert(std::is_floating_point<_RealType>::value,
1782	"result_type must be a floating point type");
1783
1784	public:
1785	/** The type of the range of the distribution. */
1786	typedef _RealType result_type;
1787
1788	/** Parameter type. */
1789	struct param_type
1790	{
1791	typedef uniform_real_distribution<_RealType> distribution_type;
1792
1793	param_type() : param_type(0) { }
1794
1795	explicit
1796	param_type(_RealType __a, _RealType __b = _RealType(1))
1797	: _M_a(__a), _M_b(__b)
1798	{
1799	__glibcxx_assert(_M_a <= _M_b);
1800	}
1801
1802	result_type
1803	a() const
1804	{ return _M_a; }
1805
1806	result_type
1807	b() const
1808	{ return _M_b; }
1809
1810	friend bool
1811	operator==(const param_type& __p1, const param_type& __p2)
1812	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1813
1814	#if __cpp_impl_three_way_comparison < 201907L
1815	friend bool
1816	operator!=(const param_type& __p1, const param_type& __p2)
1817	{ return !(__p1 == __p2); }
1818	#endif
1819
1820	private:
1821	_RealType _M_a;
1822	_RealType _M_b;
1823	};
1824
1825	public:
1826	/**
1827	* @brief Constructs a uniform_real_distribution object.
1828	*
1829	* The lower bound is set to 0.0 and the upper bound to 1.0
1830	*/
1831	uniform_real_distribution() : uniform_real_distribution(0.0) { }
1832
1833	/**
1834	* @brief Constructs a uniform_real_distribution object.
1835	*
1836	* @param __a [IN] The lower bound of the distribution.
1837	* @param __b [IN] The upper bound of the distribution.
1838	*/
1839	explicit
1840	uniform_real_distribution(_RealType __a, _RealType __b = _RealType(1))
1841	: _M_param(__a, __b)
1842	{ }
1843
1844	explicit
1845	uniform_real_distribution(const param_type& __p)
1846	: _M_param(__p)
1847	{ }
1848
1849	/**
1850	* @brief Resets the distribution state.
1851	*
1852	* Does nothing for the uniform real distribution.
1853	*/
1854	void
1855	reset() { }
1856
1857	result_type
1858	a() const
1859	{ return _M_param.a(); }
1860
1861	result_type
1862	b() const
1863	{ return _M_param.b(); }
1864
1865	/**
1866	* @brief Returns the parameter set of the distribution.
1867	*/
1868	param_type
1869	param() const
1870	{ return _M_param; }
1871
1872	/**
1873	* @brief Sets the parameter set of the distribution.
1874	* @param __param The new parameter set of the distribution.
1875	*/
1876	void
1877	param(const param_type& __param)
1878	{ _M_param = __param; }
1879
1880	/**
1881	* @brief Returns the inclusive lower bound of the distribution range.
1882	*/
1883	result_type
1884	min() const
1885	{ return this->a(); }
1886
1887	/**
1888	* @brief Returns the inclusive upper bound of the distribution range.
1889	*/
1890	result_type
1891	max() const
1892	{ return this->b(); }
1893
1894	/**
1895	* @brief Generating functions.
1896	*/
1897	template<typename _UniformRandomNumberGenerator>
1898	result_type
1899	operator()(_UniformRandomNumberGenerator& __urng)
1900	{ return this->operator()(__urng, _M_param); }
1901
1902	template<typename _UniformRandomNumberGenerator>
1903	result_type
1904	operator()(_UniformRandomNumberGenerator& __urng,
1905	const param_type& __p)
1906	{
1907	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1908	__aurng(__urng);
1909	return (__aurng() * (__p.b() - __p.a())) + __p.a();
1910	}
1911
1912	template<typename _ForwardIterator,
1913	typename _UniformRandomNumberGenerator>
1914	void
1915	__generate(_ForwardIterator __f, _ForwardIterator __t,
1916	_UniformRandomNumberGenerator& __urng)
1917	{ this->__generate(__f, __t, __urng, _M_param); }
1918
1919	template<typename _ForwardIterator,
1920	typename _UniformRandomNumberGenerator>
1921	void
1922	__generate(_ForwardIterator __f, _ForwardIterator __t,
1923	_UniformRandomNumberGenerator& __urng,
1924	const param_type& __p)
1925	{ this->__generate_impl(__f, __t, __urng, __p); }
1926
1927	template<typename _UniformRandomNumberGenerator>
1928	void
1929	__generate(result_type* __f, result_type* __t,
1930	_UniformRandomNumberGenerator& __urng,
1931	const param_type& __p)
1932	{ this->__generate_impl(__f, __t, __urng, __p); }
1933
1934	/**
1935	* @brief Return true if two uniform real distributions have
1936	* the same parameters.
1937	*/
1938	friend bool
1939	operator==(const uniform_real_distribution& __d1,
1940	const uniform_real_distribution& __d2)
1941	{ return __d1._M_param == __d2._M_param; }
1942
1943	private:
1944	template<typename _ForwardIterator,
1945	typename _UniformRandomNumberGenerator>
1946	void
1947	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1948	_UniformRandomNumberGenerator& __urng,
1949	const param_type& __p);
1950
1951	param_type _M_param;
1952	};
1953
1954	#if __cpp_impl_three_way_comparison < 201907L
1955	/**
1956	* @brief Return true if two uniform real distributions have
1957	* different parameters.
1958	*/
1959	template<typename _IntType>
1960	inline bool
1961	operator!=(const std::uniform_real_distribution<_IntType>& __d1,
1962	const std::uniform_real_distribution<_IntType>& __d2)
1963	{ return !(__d1 == __d2); }
1964	#endif
1965
1966	/**
1967	* @brief Inserts a %uniform_real_distribution random number
1968	* distribution @p __x into the output stream @p __os.
1969	*
1970	* @param __os An output stream.
1971	* @param __x A %uniform_real_distribution random number distribution.
1972	*
1973	* @returns The output stream with the state of @p __x inserted or in
1974	* an error state.
1975	*/
1976	template<typename _RealType, typename _CharT, typename _Traits>
1977	std::basic_ostream<_CharT, _Traits>&
1978	operator<<(std::basic_ostream<_CharT, _Traits>&,
1979	const std::uniform_real_distribution<_RealType>&);
1980
1981	/**
1982	* @brief Extracts a %uniform_real_distribution random number distribution
1983	* @p __x from the input stream @p __is.
1984	*
1985	* @param __is An input stream.
1986	* @param __x A %uniform_real_distribution random number generator engine.
1987	*
1988	* @returns The input stream with @p __x extracted or in an error state.
1989	*/
1990	template<typename _RealType, typename _CharT, typename _Traits>
1991	std::basic_istream<_CharT, _Traits>&
1992	operator>>(std::basic_istream<_CharT, _Traits>&,
1993	std::uniform_real_distribution<_RealType>&);
1994
1995	/// @} group random_distributions_uniform
1996
1997	/**
1998	* @addtogroup random_distributions_normal Normal Distributions
1999	* @ingroup random_distributions
2000	* @{
2001	*/
2002
2003	/**
2004	* @brief A normal continuous distribution for random numbers.
2005	*
2006	* The formula for the normal probability density function is
2007	* @f[
2008	* p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
2009	* e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
2010	* @f]
2011	*
2012	* @headerfile random
2013	* @since C++11
2014	*/
2015	template<typename _RealType = double>
2016	class normal_distribution
2017	{
2018	static_assert(std::is_floating_point<_RealType>::value,
2019	"result_type must be a floating point type");
2020
2021	public:
2022	/** The type of the range of the distribution. */
2023	typedef _RealType result_type;
2024
2025	/** Parameter type. */
2026	struct param_type
2027	{
2028	typedef normal_distribution<_RealType> distribution_type;
2029
2030	param_type() : param_type(0.0) { }
2031
2032	explicit
2033	param_type(_RealType __mean, _RealType __stddev = _RealType(1))
2034	: _M_mean(__mean), _M_stddev(__stddev)
2035	{
2036	__glibcxx_assert(_M_stddev > _RealType(0));
2037	}
2038
2039	_RealType
2040	mean() const
2041	{ return _M_mean; }
2042
2043	_RealType
2044	stddev() const
2045	{ return _M_stddev; }
2046
2047	friend bool
2048	operator==(const param_type& __p1, const param_type& __p2)
2049	{ return (__p1._M_mean == __p2._M_mean
2050	&& __p1._M_stddev == __p2._M_stddev); }
2051
2052	#if __cpp_impl_three_way_comparison < 201907L
2053	friend bool
2054	operator!=(const param_type& __p1, const param_type& __p2)
2055	{ return !(__p1 == __p2); }
2056	#endif
2057
2058	private:
2059	_RealType _M_mean;
2060	_RealType _M_stddev;
2061	};
2062
2063	public:
2064	normal_distribution() : normal_distribution(0.0) { }
2065
2066	/**
2067	* Constructs a normal distribution with parameters @f$mean@f$ and
2068	* standard deviation.
2069	*/
2070	explicit
2071	normal_distribution(result_type __mean,
2072	result_type __stddev = result_type(1))
2073	: _M_param(__mean, __stddev)
2074	{ }
2075
2076	explicit
2077	normal_distribution(const param_type& __p)
2078	: _M_param(__p)
2079	{ }
2080
2081	/**
2082	* @brief Resets the distribution state.
2083	*/
2084	void
2085	reset()
2086	{ _M_saved_available = false; }
2087
2088	/**
2089	* @brief Returns the mean of the distribution.
2090	*/
2091	_RealType
2092	mean() const
2093	{ return _M_param.mean(); }
2094
2095	/**
2096	* @brief Returns the standard deviation of the distribution.
2097	*/
2098	_RealType
2099	stddev() const
2100	{ return _M_param.stddev(); }
2101
2102	/**
2103	* @brief Returns the parameter set of the distribution.
2104	*/
2105	param_type
2106	param() const
2107	{ return _M_param; }
2108
2109	/**
2110	* @brief Sets the parameter set of the distribution.
2111	* @param __param The new parameter set of the distribution.
2112	*/
2113	void
2114	param(const param_type& __param)
2115	{ _M_param = __param; }
2116
2117	/**
2118	* @brief Returns the greatest lower bound value of the distribution.
2119	*/
2120	result_type
2121	min() const
2122	{ return std::numeric_limits<result_type>::lowest(); }
2123
2124	/**
2125	* @brief Returns the least upper bound value of the distribution.
2126	*/
2127	result_type
2128	max() const
2129	{ return std::numeric_limits<result_type>::max(); }
2130
2131	/**
2132	* @brief Generating functions.
2133	*/
2134	template<typename _UniformRandomNumberGenerator>
2135	result_type
2136	operator()(_UniformRandomNumberGenerator& __urng)
2137	{ return this->operator()(__urng, _M_param); }
2138
2139	template<typename _UniformRandomNumberGenerator>
2140	result_type
2141	operator()(_UniformRandomNumberGenerator& __urng,
2142	const param_type& __p);
2143
2144	template<typename _ForwardIterator,
2145	typename _UniformRandomNumberGenerator>
2146	void
2147	__generate(_ForwardIterator __f, _ForwardIterator __t,
2148	_UniformRandomNumberGenerator& __urng)
2149	{ this->__generate(__f, __t, __urng, _M_param); }
2150
2151	template<typename _ForwardIterator,
2152	typename _UniformRandomNumberGenerator>
2153	void
2154	__generate(_ForwardIterator __f, _ForwardIterator __t,
2155	_UniformRandomNumberGenerator& __urng,
2156	const param_type& __p)
2157	{ this->__generate_impl(__f, __t, __urng, __p); }
2158
2159	template<typename _UniformRandomNumberGenerator>
2160	void
2161	__generate(result_type* __f, result_type* __t,
2162	_UniformRandomNumberGenerator& __urng,
2163	const param_type& __p)
2164	{ this->__generate_impl(__f, __t, __urng, __p); }
2165
2166	/**
2167	* @brief Return true if two normal distributions have
2168	* the same parameters and the sequences that would
2169	* be generated are equal.
2170	*/
2171	template<typename _RealType1>
2172	friend bool
2173	operator==(const std::normal_distribution<_RealType1>& __d1,
2174	const std::normal_distribution<_RealType1>& __d2);
2175
2176	/**
2177	* @brief Inserts a %normal_distribution random number distribution
2178	* @p __x into the output stream @p __os.
2179	*
2180	* @param __os An output stream.
2181	* @param __x A %normal_distribution random number distribution.
2182	*
2183	* @returns The output stream with the state of @p __x inserted or in
2184	* an error state.
2185	*/
2186	template<typename _RealType1, typename _CharT, typename _Traits>
2187	friend std::basic_ostream<_CharT, _Traits>&
2188	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2189	const std::normal_distribution<_RealType1>& __x);
2190
2191	/**
2192	* @brief Extracts a %normal_distribution random number distribution
2193	* @p __x from the input stream @p __is.
2194	*
2195	* @param __is An input stream.
2196	* @param __x A %normal_distribution random number generator engine.
2197	*
2198	* @returns The input stream with @p __x extracted or in an error
2199	* state.
2200	*/
2201	template<typename _RealType1, typename _CharT, typename _Traits>
2202	friend std::basic_istream<_CharT, _Traits>&
2203	operator>>(std::basic_istream<_CharT, _Traits>& __is,
2204	std::normal_distribution<_RealType1>& __x);
2205
2206	private:
2207	template<typename _ForwardIterator,
2208	typename _UniformRandomNumberGenerator>
2209	void
2210	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2211	_UniformRandomNumberGenerator& __urng,
2212	const param_type& __p);
2213
2214	param_type _M_param;
2215	result_type _M_saved = 0;
2216	bool _M_saved_available = false;
2217	};
2218
2219	#if __cpp_impl_three_way_comparison < 201907L
2220	/**
2221	* @brief Return true if two normal distributions are different.
2222	*/
2223	template<typename _RealType>
2224	inline bool
2225	operator!=(const std::normal_distribution<_RealType>& __d1,
2226	const std::normal_distribution<_RealType>& __d2)
2227	{ return !(__d1 == __d2); }
2228	#endif
2229
2230	/**
2231	* @brief A lognormal_distribution random number distribution.
2232	*
2233	* The formula for the normal probability mass function is
2234	* @f[
2235	* p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
2236	* \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
2237	* @f]
2238	*
2239	* @headerfile random
2240	* @since C++11
2241	*/
2242	template<typename _RealType = double>
2243	class lognormal_distribution
2244	{
2245	static_assert(std::is_floating_point<_RealType>::value,
2246	"result_type must be a floating point type");
2247
2248	public:
2249	/** The type of the range of the distribution. */
2250	typedef _RealType result_type;
2251
2252	/** Parameter type. */
2253	struct param_type
2254	{
2255	typedef lognormal_distribution<_RealType> distribution_type;
2256
2257	param_type() : param_type(0.0) { }
2258
2259	explicit
2260	param_type(_RealType __m, _RealType __s = _RealType(1))
2261	: _M_m(__m), _M_s(__s)
2262	{ }
2263
2264	_RealType
2265	m() const
2266	{ return _M_m; }
2267
2268	_RealType
2269	s() const
2270	{ return _M_s; }
2271
2272	friend bool
2273	operator==(const param_type& __p1, const param_type& __p2)
2274	{ return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2275
2276	#if __cpp_impl_three_way_comparison < 201907L
2277	friend bool
2278	operator!=(const param_type& __p1, const param_type& __p2)
2279	{ return !(__p1 == __p2); }
2280	#endif
2281
2282	private:
2283	_RealType _M_m;
2284	_RealType _M_s;
2285	};
2286
2287	lognormal_distribution() : lognormal_distribution(0.0) { }
2288
2289	explicit
2290	lognormal_distribution(_RealType __m, _RealType __s = _RealType(1))
2291	: _M_param(__m, __s), _M_nd()
2292	{ }
2293
2294	explicit
2295	lognormal_distribution(const param_type& __p)
2296	: _M_param(__p), _M_nd()
2297	{ }
2298
2299	/**
2300	* Resets the distribution state.
2301	*/
2302	void
2303	reset()
2304	{ _M_nd.reset(); }
2305
2306	/**
2307	*
2308	*/
2309	_RealType
2310	m() const
2311	{ return _M_param.m(); }
2312
2313	_RealType
2314	s() const
2315	{ return _M_param.s(); }
2316
2317	/**
2318	* @brief Returns the parameter set of the distribution.
2319	*/
2320	param_type
2321	param() const
2322	{ return _M_param; }
2323
2324	/**
2325	* @brief Sets the parameter set of the distribution.
2326	* @param __param The new parameter set of the distribution.
2327	*/
2328	void
2329	param(const param_type& __param)
2330	{ _M_param = __param; }
2331
2332	/**
2333	* @brief Returns the greatest lower bound value of the distribution.
2334	*/
2335	result_type
2336	min() const
2337	{ return result_type(0); }
2338
2339	/**
2340	* @brief Returns the least upper bound value of the distribution.
2341	*/
2342	result_type
2343	max() const
2344	{ return std::numeric_limits<result_type>::max(); }
2345
2346	/**
2347	* @brief Generating functions.
2348	*/
2349	template<typename _UniformRandomNumberGenerator>
2350	result_type
2351	operator()(_UniformRandomNumberGenerator& __urng)
2352	{ return this->operator()(__urng, _M_param); }
2353
2354	template<typename _UniformRandomNumberGenerator>
2355	result_type
2356	operator()(_UniformRandomNumberGenerator& __urng,
2357	const param_type& __p)
2358	{ return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2359
2360	template<typename _ForwardIterator,
2361	typename _UniformRandomNumberGenerator>
2362	void
2363	__generate(_ForwardIterator __f, _ForwardIterator __t,
2364	_UniformRandomNumberGenerator& __urng)
2365	{ this->__generate(__f, __t, __urng, _M_param); }
2366
2367	template<typename _ForwardIterator,
2368	typename _UniformRandomNumberGenerator>
2369	void
2370	__generate(_ForwardIterator __f, _ForwardIterator __t,
2371	_UniformRandomNumberGenerator& __urng,
2372	const param_type& __p)
2373	{ this->__generate_impl(__f, __t, __urng, __p); }
2374
2375	template<typename _UniformRandomNumberGenerator>
2376	void
2377	__generate(result_type* __f, result_type* __t,
2378	_UniformRandomNumberGenerator& __urng,
2379	const param_type& __p)
2380	{ this->__generate_impl(__f, __t, __urng, __p); }
2381
2382	/**
2383	* @brief Return true if two lognormal distributions have
2384	* the same parameters and the sequences that would
2385	* be generated are equal.
2386	*/
2387	friend bool
2388	operator==(const lognormal_distribution& __d1,
2389	const lognormal_distribution& __d2)
2390	{ return (__d1._M_param == __d2._M_param
2391	&& __d1._M_nd == __d2._M_nd); }
2392
2393	/**
2394	* @brief Inserts a %lognormal_distribution random number distribution
2395	* @p __x into the output stream @p __os.
2396	*
2397	* @param __os An output stream.
2398	* @param __x A %lognormal_distribution random number distribution.
2399	*
2400	* @returns The output stream with the state of @p __x inserted or in
2401	* an error state.
2402	*/
2403	template<typename _RealType1, typename _CharT, typename _Traits>
2404	friend std::basic_ostream<_CharT, _Traits>&
2405	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2406	const std::lognormal_distribution<_RealType1>& __x);
2407
2408	/**
2409	* @brief Extracts a %lognormal_distribution random number distribution
2410	* @p __x from the input stream @p __is.
2411	*
2412	* @param __is An input stream.
2413	* @param __x A %lognormal_distribution random number
2414	* generator engine.
2415	*
2416	* @returns The input stream with @p __x extracted or in an error state.
2417	*/
2418	template<typename _RealType1, typename _CharT, typename _Traits>
2419	friend std::basic_istream<_CharT, _Traits>&
2420	operator>>(std::basic_istream<_CharT, _Traits>& __is,
2421	std::lognormal_distribution<_RealType1>& __x);
2422
2423	private:
2424	template<typename _ForwardIterator,
2425	typename _UniformRandomNumberGenerator>
2426	void
2427	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2428	_UniformRandomNumberGenerator& __urng,
2429	const param_type& __p);
2430
2431	param_type _M_param;
2432
2433	std::normal_distribution<result_type> _M_nd;
2434	};
2435
2436	#if __cpp_impl_three_way_comparison < 201907L
2437	/**
2438	* @brief Return true if two lognormal distributions are different.
2439	*/
2440	template<typename _RealType>
2441	inline bool
2442	operator!=(const std::lognormal_distribution<_RealType>& __d1,
2443	const std::lognormal_distribution<_RealType>& __d2)
2444	{ return !(__d1 == __d2); }
2445	#endif
2446
2447	/// @} group random_distributions_normal
2448
2449	/**
2450	* @addtogroup random_distributions_poisson Poisson Distributions
2451	* @ingroup random_distributions
2452	* @{
2453	*/
2454
2455	/**
2456	* @brief A gamma continuous distribution for random numbers.
2457	*
2458	* The formula for the gamma probability density function is:
2459	* @f[
2460	* p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
2461	* (x/\beta)^{\alpha - 1} e^{-x/\beta}
2462	* @f]
2463	*
2464	* @headerfile random
2465	* @since C++11
2466	*/
2467	template<typename _RealType = double>
2468	class gamma_distribution
2469	{
2470	static_assert(std::is_floating_point<_RealType>::value,
2471	"result_type must be a floating point type");
2472
2473	public:
2474	/** The type of the range of the distribution. */
2475	typedef _RealType result_type;
2476
2477	/** Parameter type. */
2478	struct param_type
2479	{
2480	typedef gamma_distribution<_RealType> distribution_type;
2481	friend class gamma_distribution<_RealType>;
2482
2483	param_type() : param_type(1.0) { }
2484
2485	explicit
2486	param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2487	: _M_alpha(__alpha_val), _M_beta(__beta_val)
2488	{
2489	__glibcxx_assert(_M_alpha > _RealType(0));
2490	_M_initialize();
2491	}
2492
2493	_RealType
2494	alpha() const
2495	{ return _M_alpha; }
2496
2497	_RealType
2498	beta() const
2499	{ return _M_beta; }
2500
2501	friend bool
2502	operator==(const param_type& __p1, const param_type& __p2)
2503	{ return (__p1._M_alpha == __p2._M_alpha
2504	&& __p1._M_beta == __p2._M_beta); }
2505
2506	#if __cpp_impl_three_way_comparison < 201907L
2507	friend bool
2508	operator!=(const param_type& __p1, const param_type& __p2)
2509	{ return !(__p1 == __p2); }
2510	#endif
2511
2512	private:
2513	void
2514	_M_initialize();
2515
2516	_RealType _M_alpha;
2517	_RealType _M_beta;
2518
2519	_RealType _M_malpha, _M_a2;
2520	};
2521
2522	public:
2523	/**
2524	* @brief Constructs a gamma distribution with parameters 1 and 1.
2525	*/
2526	gamma_distribution() : gamma_distribution(1.0) { }
2527
2528	/**
2529	* @brief Constructs a gamma distribution with parameters
2530	* @f$\alpha@f$ and @f$\beta@f$.
2531	*/
2532	explicit
2533	gamma_distribution(_RealType __alpha_val,
2534	_RealType __beta_val = _RealType(1))
2535	: _M_param(__alpha_val, __beta_val), _M_nd()
2536	{ }
2537
2538	explicit
2539	gamma_distribution(const param_type& __p)
2540	: _M_param(__p), _M_nd()
2541	{ }
2542
2543	/**
2544	* @brief Resets the distribution state.
2545	*/
2546	void
2547	reset()
2548	{ _M_nd.reset(); }
2549
2550	/**
2551	* @brief Returns the @f$\alpha@f$ of the distribution.
2552	*/
2553	_RealType
2554	alpha() const
2555	{ return _M_param.alpha(); }
2556
2557	/**
2558	* @brief Returns the @f$\beta@f$ of the distribution.
2559	*/
2560	_RealType
2561	beta() const
2562	{ return _M_param.beta(); }
2563
2564	/**
2565	* @brief Returns the parameter set of the distribution.
2566	*/
2567	param_type
2568	param() const
2569	{ return _M_param; }
2570
2571	/**
2572	* @brief Sets the parameter set of the distribution.
2573	* @param __param The new parameter set of the distribution.
2574	*/
2575	void
2576	param(const param_type& __param)
2577	{ _M_param = __param; }
2578
2579	/**
2580	* @brief Returns the greatest lower bound value of the distribution.
2581	*/
2582	result_type
2583	min() const
2584	{ return result_type(0); }
2585
2586	/**
2587	* @brief Returns the least upper bound value of the distribution.
2588	*/
2589	result_type
2590	max() const
2591	{ return std::numeric_limits<result_type>::max(); }
2592
2593	/**
2594	* @brief Generating functions.
2595	*/
2596	template<typename _UniformRandomNumberGenerator>
2597	result_type
2598	operator()(_UniformRandomNumberGenerator& __urng)
2599	{ return this->operator()(__urng, _M_param); }
2600
2601	template<typename _UniformRandomNumberGenerator>
2602	result_type
2603	operator()(_UniformRandomNumberGenerator& __urng,
2604	const param_type& __p);
2605
2606	template<typename _ForwardIterator,
2607	typename _UniformRandomNumberGenerator>
2608	void
2609	__generate(_ForwardIterator __f, _ForwardIterator __t,
2610	_UniformRandomNumberGenerator& __urng)
2611	{ this->__generate(__f, __t, __urng, _M_param); }
2612
2613	template<typename _ForwardIterator,
2614	typename _UniformRandomNumberGenerator>
2615	void
2616	__generate(_ForwardIterator __f, _ForwardIterator __t,
2617	_UniformRandomNumberGenerator& __urng,
2618	const param_type& __p)
2619	{ this->__generate_impl(__f, __t, __urng, __p); }
2620
2621	template<typename _UniformRandomNumberGenerator>
2622	void
2623	__generate(result_type* __f, result_type* __t,
2624	_UniformRandomNumberGenerator& __urng,
2625	const param_type& __p)
2626	{ this->__generate_impl(__f, __t, __urng, __p); }
2627
2628	/**
2629	* @brief Return true if two gamma distributions have the same
2630	* parameters and the sequences that would be generated
2631	* are equal.
2632	*/
2633	friend bool
2634	operator==(const gamma_distribution& __d1,
2635	const gamma_distribution& __d2)
2636	{ return (__d1._M_param == __d2._M_param
2637	&& __d1._M_nd == __d2._M_nd); }
2638
2639	/**
2640	* @brief Inserts a %gamma_distribution random number distribution
2641	* @p __x into the output stream @p __os.
2642	*
2643	* @param __os An output stream.
2644	* @param __x A %gamma_distribution random number distribution.
2645	*
2646	* @returns The output stream with the state of @p __x inserted or in
2647	* an error state.
2648	*/
2649	template<typename _RealType1, typename _CharT, typename _Traits>
2650	friend std::basic_ostream<_CharT, _Traits>&
2651	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2652	const std::gamma_distribution<_RealType1>& __x);
2653
2654	/**
2655	* @brief Extracts a %gamma_distribution random number distribution
2656	* @p __x from the input stream @p __is.
2657	*
2658	* @param __is An input stream.
2659	* @param __x A %gamma_distribution random number generator engine.
2660	*
2661	* @returns The input stream with @p __x extracted or in an error state.
2662	*/
2663	template<typename _RealType1, typename _CharT, typename _Traits>
2664	friend std::basic_istream<_CharT, _Traits>&
2665	operator>>(std::basic_istream<_CharT, _Traits>& __is,
2666	std::gamma_distribution<_RealType1>& __x);
2667
2668	private:
2669	template<typename _ForwardIterator,
2670	typename _UniformRandomNumberGenerator>
2671	void
2672	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2673	_UniformRandomNumberGenerator& __urng,
2674	const param_type& __p);
2675
2676	param_type _M_param;
2677
2678	std::normal_distribution<result_type> _M_nd;
2679	};
2680
2681	#if __cpp_impl_three_way_comparison < 201907L
2682	/**
2683	* @brief Return true if two gamma distributions are different.
2684	*/
2685	template<typename _RealType>
2686	inline bool
2687	operator!=(const std::gamma_distribution<_RealType>& __d1,
2688	const std::gamma_distribution<_RealType>& __d2)
2689	{ return !(__d1 == __d2); }
2690	#endif
2691
2692	/// @} group random_distributions_poisson
2693
2694	/**
2695	* @addtogroup random_distributions_normal Normal Distributions
2696	* @ingroup random_distributions
2697	* @{
2698	*/
2699
2700	/**
2701	* @brief A chi_squared_distribution random number distribution.
2702	*
2703	* The formula for the normal probability mass function is
2704	* @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
2705	*
2706	* @headerfile random
2707	* @since C++11
2708	*/
2709	template<typename _RealType = double>
2710	class chi_squared_distribution
2711	{
2712	static_assert(std::is_floating_point<_RealType>::value,
2713	"result_type must be a floating point type");
2714
2715	public:
2716	/** The type of the range of the distribution. */
2717	typedef _RealType result_type;
2718
2719	/** Parameter type. */
2720	struct param_type
2721	{
2722	typedef chi_squared_distribution<_RealType> distribution_type;
2723
2724	param_type() : param_type(1) { }
2725
2726	explicit
2727	param_type(_RealType __n)
2728	: _M_n(__n)
2729	{ }
2730
2731	_RealType
2732	n() const
2733	{ return _M_n; }
2734
2735	friend bool
2736	operator==(const param_type& __p1, const param_type& __p2)
2737	{ return __p1._M_n == __p2._M_n; }
2738
2739	#if __cpp_impl_three_way_comparison < 201907L
2740	friend bool
2741	operator!=(const param_type& __p1, const param_type& __p2)
2742	{ return !(__p1 == __p2); }
2743	#endif
2744
2745	private:
2746	_RealType _M_n;
2747	};
2748
2749	chi_squared_distribution() : chi_squared_distribution(1) { }
2750
2751	explicit
2752	chi_squared_distribution(_RealType __n)
2753	: _M_param(__n), _M_gd(__n / 2)
2754	{ }
2755
2756	explicit
2757	chi_squared_distribution(const param_type& __p)
2758	: _M_param(__p), _M_gd(__p.n() / 2)
2759	{ }
2760
2761	/**
2762	* @brief Resets the distribution state.
2763	*/
2764	void
2765	reset()
2766	{ _M_gd.reset(); }
2767
2768	/**
2769	*
2770	*/
2771	_RealType
2772	n() const
2773	{ return _M_param.n(); }
2774
2775	/**
2776	* @brief Returns the parameter set of the distribution.
2777	*/
2778	param_type
2779	param() const
2780	{ return _M_param; }
2781
2782	/**
2783	* @brief Sets the parameter set of the distribution.
2784	* @param __param The new parameter set of the distribution.
2785	*/
2786	void
2787	param(const param_type& __param)
2788	{
2789	_M_param = __param;
2790	typedef typename std::gamma_distribution<result_type>::param_type
2791	param_type;
2792	_M_gd.param(param_type{__param.n() / 2});
2793	}
2794
2795	/**
2796	* @brief Returns the greatest lower bound value of the distribution.
2797	*/
2798	result_type
2799	min() const
2800	{ return result_type(0); }
2801
2802	/**
2803	* @brief Returns the least upper bound value of the distribution.
2804	*/
2805	result_type
2806	max() const
2807	{ return std::numeric_limits<result_type>::max(); }
2808
2809	/**
2810	* @brief Generating functions.
2811	*/
2812	template<typename _UniformRandomNumberGenerator>
2813	result_type
2814	operator()(_UniformRandomNumberGenerator& __urng)
2815	{ return 2 * _M_gd(__urng); }
2816
2817	template<typename _UniformRandomNumberGenerator>
2818	result_type
2819	operator()(_UniformRandomNumberGenerator& __urng,
2820	const param_type& __p)
2821	{
2822	typedef typename std::gamma_distribution<result_type>::param_type
2823	param_type;
2824	return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2825	}
2826
2827	template<typename _ForwardIterator,
2828	typename _UniformRandomNumberGenerator>
2829	void
2830	__generate(_ForwardIterator __f, _ForwardIterator __t,
2831	_UniformRandomNumberGenerator& __urng)
2832	{ this->__generate_impl(__f, __t, __urng); }
2833
2834	template<typename _ForwardIterator,
2835	typename _UniformRandomNumberGenerator>
2836	void
2837	__generate(_ForwardIterator __f, _ForwardIterator __t,
2838	_UniformRandomNumberGenerator& __urng,
2839	const param_type& __p)
2840	{ typename std::gamma_distribution<result_type>::param_type
2841	__p2(__p.n() / 2);
2842	this->__generate_impl(__f, __t, __urng, __p2); }
2843
2844	template<typename _UniformRandomNumberGenerator>
2845	void
2846	__generate(result_type* __f, result_type* __t,
2847	_UniformRandomNumberGenerator& __urng)
2848	{ this->__generate_impl(__f, __t, __urng); }
2849
2850	template<typename _UniformRandomNumberGenerator>
2851	void
2852	__generate(result_type* __f, result_type* __t,
2853	_UniformRandomNumberGenerator& __urng,
2854	const param_type& __p)
2855	{ typename std::gamma_distribution<result_type>::param_type
2856	__p2(__p.n() / 2);
2857	this->__generate_impl(__f, __t, __urng, __p2); }
2858
2859	/**
2860	* @brief Return true if two Chi-squared distributions have
2861	* the same parameters and the sequences that would be
2862	* generated are equal.
2863	*/
2864	friend bool
2865	operator==(const chi_squared_distribution& __d1,
2866	const chi_squared_distribution& __d2)
2867	{ return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2868
2869	/**
2870	* @brief Inserts a %chi_squared_distribution random number distribution
2871	* @p __x into the output stream @p __os.
2872	*
2873	* @param __os An output stream.
2874	* @param __x A %chi_squared_distribution random number distribution.
2875	*
2876	* @returns The output stream with the state of @p __x inserted or in
2877	* an error state.
2878	*/
2879	template<typename _RealType1, typename _CharT, typename _Traits>
2880	friend std::basic_ostream<_CharT, _Traits>&
2881	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2882	const std::chi_squared_distribution<_RealType1>& __x);
2883
2884	/**
2885	* @brief Extracts a %chi_squared_distribution random number distribution
2886	* @p __x from the input stream @p __is.
2887	*
2888	* @param __is An input stream.
2889	* @param __x A %chi_squared_distribution random number
2890	* generator engine.
2891	*
2892	* @returns The input stream with @p __x extracted or in an error state.
2893	*/
2894	template<typename _RealType1, typename _CharT, typename _Traits>
2895	friend std::basic_istream<_CharT, _Traits>&
2896	operator>>(std::basic_istream<_CharT, _Traits>& __is,
2897	std::chi_squared_distribution<_RealType1>& __x);
2898
2899	private:
2900	template<typename _ForwardIterator,
2901	typename _UniformRandomNumberGenerator>
2902	void
2903	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2904	_UniformRandomNumberGenerator& __urng);
2905
2906	template<typename _ForwardIterator,
2907	typename _UniformRandomNumberGenerator>
2908	void
2909	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2910	_UniformRandomNumberGenerator& __urng,
2911	const typename
2912	std::gamma_distribution<result_type>::param_type& __p);
2913
2914	param_type _M_param;
2915
2916	std::gamma_distribution<result_type> _M_gd;
2917	};
2918
2919	#if __cpp_impl_three_way_comparison < 201907L
2920	/**
2921	* @brief Return true if two Chi-squared distributions are different.
2922	*/
2923	template<typename _RealType>
2924	inline bool
2925	operator!=(const std::chi_squared_distribution<_RealType>& __d1,
2926	const std::chi_squared_distribution<_RealType>& __d2)
2927	{ return !(__d1 == __d2); }
2928	#endif
2929
2930	/**
2931	* @brief A cauchy_distribution random number distribution.
2932	*
2933	* The formula for the normal probability mass function is
2934	* @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
2935	*
2936	* @headerfile random
2937	* @since C++11
2938	*/
2939	template<typename _RealType = double>
2940	class cauchy_distribution
2941	{
2942	static_assert(std::is_floating_point<_RealType>::value,
2943	"result_type must be a floating point type");
2944
2945	public:
2946	/** The type of the range of the distribution. */
2947	typedef _RealType result_type;
2948
2949	/** Parameter type. */
2950	struct param_type
2951	{
2952	typedef cauchy_distribution<_RealType> distribution_type;
2953
2954	param_type() : param_type(0) { }
2955
2956	explicit
2957	param_type(_RealType __a, _RealType __b = _RealType(1))
2958	: _M_a(__a), _M_b(__b)
2959	{ }
2960
2961	_RealType
2962	a() const
2963	{ return _M_a; }
2964
2965	_RealType
2966	b() const
2967	{ return _M_b; }
2968
2969	friend bool
2970	operator==(const param_type& __p1, const param_type& __p2)
2971	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2972
2973	#if __cpp_impl_three_way_comparison < 201907L
2974	friend bool
2975	operator!=(const param_type& __p1, const param_type& __p2)
2976	{ return !(__p1 == __p2); }
2977	#endif
2978
2979	private:
2980	_RealType _M_a;
2981	_RealType _M_b;
2982	};
2983
2984	cauchy_distribution() : cauchy_distribution(0.0) { }
2985
2986	explicit
2987	cauchy_distribution(_RealType __a, _RealType __b = 1.0)
2988	: _M_param(__a, __b)
2989	{ }
2990
2991	explicit
2992	cauchy_distribution(const param_type& __p)
2993	: _M_param(__p)
2994	{ }
2995
2996	/**
2997	* @brief Resets the distribution state.
2998	*/
2999	void
3000	reset()
3001	{ }
3002
3003	/**
3004	*
3005	*/
3006	_RealType
3007	a() const
3008	{ return _M_param.a(); }
3009
3010	_RealType
3011	b() const
3012	{ return _M_param.b(); }
3013
3014	/**
3015	* @brief Returns the parameter set of the distribution.
3016	*/
3017	param_type
3018	param() const
3019	{ return _M_param; }
3020
3021	/**
3022	* @brief Sets the parameter set of the distribution.
3023	* @param __param The new parameter set of the distribution.
3024	*/
3025	void
3026	param(const param_type& __param)
3027	{ _M_param = __param; }
3028
3029	/**
3030	* @brief Returns the greatest lower bound value of the distribution.
3031	*/
3032	result_type
3033	min() const
3034	{ return std::numeric_limits<result_type>::lowest(); }
3035
3036	/**
3037	* @brief Returns the least upper bound value of the distribution.
3038	*/
3039	result_type
3040	max() const
3041	{ return std::numeric_limits<result_type>::max(); }
3042
3043	/**
3044	* @brief Generating functions.
3045	*/
3046	template<typename _UniformRandomNumberGenerator>
3047	result_type
3048	operator()(_UniformRandomNumberGenerator& __urng)
3049	{ return this->operator()(__urng, _M_param); }
3050
3051	template<typename _UniformRandomNumberGenerator>
3052	result_type
3053	operator()(_UniformRandomNumberGenerator& __urng,
3054	const param_type& __p);
3055
3056	template<typename _ForwardIterator,
3057	typename _UniformRandomNumberGenerator>
3058	void
3059	__generate(_ForwardIterator __f, _ForwardIterator __t,
3060	_UniformRandomNumberGenerator& __urng)
3061	{ this->__generate(__f, __t, __urng, _M_param); }
3062
3063	template<typename _ForwardIterator,
3064	typename _UniformRandomNumberGenerator>
3065	void
3066	__generate(_ForwardIterator __f, _ForwardIterator __t,
3067	_UniformRandomNumberGenerator& __urng,
3068	const param_type& __p)
3069	{ this->__generate_impl(__f, __t, __urng, __p); }
3070
3071	template<typename _UniformRandomNumberGenerator>
3072	void
3073	__generate(result_type* __f, result_type* __t,
3074	_UniformRandomNumberGenerator& __urng,
3075	const param_type& __p)
3076	{ this->__generate_impl(__f, __t, __urng, __p); }
3077
3078	/**
3079	* @brief Return true if two Cauchy distributions have
3080	* the same parameters.
3081	*/
3082	friend bool
3083	operator==(const cauchy_distribution& __d1,
3084	const cauchy_distribution& __d2)
3085	{ return __d1._M_param == __d2._M_param; }
3086
3087	private:
3088	template<typename _ForwardIterator,
3089	typename _UniformRandomNumberGenerator>
3090	void
3091	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3092	_UniformRandomNumberGenerator& __urng,
3093	const param_type& __p);
3094
3095	param_type _M_param;
3096	};
3097
3098	#if __cpp_impl_three_way_comparison < 201907L
3099	/**
3100	* @brief Return true if two Cauchy distributions have
3101	* different parameters.
3102	*/
3103	template<typename _RealType>
3104	inline bool
3105	operator!=(const std::cauchy_distribution<_RealType>& __d1,
3106	const std::cauchy_distribution<_RealType>& __d2)
3107	{ return !(__d1 == __d2); }
3108	#endif
3109
3110	/**
3111	* @brief Inserts a %cauchy_distribution random number distribution
3112	* @p __x into the output stream @p __os.
3113	*
3114	* @param __os An output stream.
3115	* @param __x A %cauchy_distribution random number distribution.
3116	*
3117	* @returns The output stream with the state of @p __x inserted or in
3118	* an error state.
3119	*/
3120	template<typename _RealType, typename _CharT, typename _Traits>
3121	std::basic_ostream<_CharT, _Traits>&
3122	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3123	const std::cauchy_distribution<_RealType>& __x);
3124
3125	/**
3126	* @brief Extracts a %cauchy_distribution random number distribution
3127	* @p __x from the input stream @p __is.
3128	*
3129	* @param __is An input stream.
3130	* @param __x A %cauchy_distribution random number
3131	* generator engine.
3132	*
3133	* @returns The input stream with @p __x extracted or in an error state.
3134	*/
3135	template<typename _RealType, typename _CharT, typename _Traits>
3136	std::basic_istream<_CharT, _Traits>&
3137	operator>>(std::basic_istream<_CharT, _Traits>& __is,
3138	std::cauchy_distribution<_RealType>& __x);
3139
3140
3141	/**
3142	* @brief A fisher_f_distribution random number distribution.
3143	*
3144	* The formula for the normal probability mass function is
3145	* @f[
3146	* p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
3147	* (\frac{m}{n})^{m/2} x^{(m/2)-1}
3148	* (1 + \frac{mx}{n})^{-(m+n)/2}
3149	* @f]
3150	*
3151	* @headerfile random
3152	* @since C++11
3153	*/
3154	template<typename _RealType = double>
3155	class fisher_f_distribution
3156	{
3157	static_assert(std::is_floating_point<_RealType>::value,
3158	"result_type must be a floating point type");
3159
3160	public:
3161	/** The type of the range of the distribution. */
3162	typedef _RealType result_type;
3163
3164	/** Parameter type. */
3165	struct param_type
3166	{
3167	typedef fisher_f_distribution<_RealType> distribution_type;
3168
3169	param_type() : param_type(1) { }
3170
3171	explicit
3172	param_type(_RealType __m, _RealType __n = _RealType(1))
3173	: _M_m(__m), _M_n(__n)
3174	{ }
3175
3176	_RealType
3177	m() const
3178	{ return _M_m; }
3179
3180	_RealType
3181	n() const
3182	{ return _M_n; }
3183
3184	friend bool
3185	operator==(const param_type& __p1, const param_type& __p2)
3186	{ return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3187
3188	#if __cpp_impl_three_way_comparison < 201907L
3189	friend bool
3190	operator!=(const param_type& __p1, const param_type& __p2)
3191	{ return !(__p1 == __p2); }
3192	#endif
3193
3194	private:
3195	_RealType _M_m;
3196	_RealType _M_n;
3197	};
3198
3199	fisher_f_distribution() : fisher_f_distribution(1.0) { }
3200
3201	explicit
3202	fisher_f_distribution(_RealType __m,
3203	_RealType __n = _RealType(1))
3204	: _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3205	{ }
3206
3207	explicit
3208	fisher_f_distribution(const param_type& __p)
3209	: _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3210	{ }
3211
3212	/**
3213	* @brief Resets the distribution state.
3214	*/
3215	void
3216	reset()
3217	{
3218	_M_gd_x.reset();
3219	_M_gd_y.reset();
3220	}
3221
3222	/**
3223	*
3224	*/
3225	_RealType
3226	m() const
3227	{ return _M_param.m(); }
3228
3229	_RealType
3230	n() const
3231	{ return _M_param.n(); }
3232
3233	/**
3234	* @brief Returns the parameter set of the distribution.
3235	*/
3236	param_type
3237	param() const
3238	{ return _M_param; }
3239
3240	/**
3241	* @brief Sets the parameter set of the distribution.
3242	* @param __param The new parameter set of the distribution.
3243	*/
3244	void
3245	param(const param_type& __param)
3246	{ _M_param = __param; }
3247
3248	/**
3249	* @brief Returns the greatest lower bound value of the distribution.
3250	*/
3251	result_type
3252	min() const
3253	{ return result_type(0); }
3254
3255	/**
3256	* @brief Returns the least upper bound value of the distribution.
3257	*/
3258	result_type
3259	max() const
3260	{ return std::numeric_limits<result_type>::max(); }
3261
3262	/**
3263	* @brief Generating functions.
3264	*/
3265	template<typename _UniformRandomNumberGenerator>
3266	result_type
3267	operator()(_UniformRandomNumberGenerator& __urng)
3268	{ return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3269
3270	template<typename _UniformRandomNumberGenerator>
3271	result_type
3272	operator()(_UniformRandomNumberGenerator& __urng,
3273	const param_type& __p)
3274	{
3275	typedef typename std::gamma_distribution<result_type>::param_type
3276	param_type;
3277	return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3278	/ (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3279	}
3280
3281	template<typename _ForwardIterator,
3282	typename _UniformRandomNumberGenerator>
3283	void
3284	__generate(_ForwardIterator __f, _ForwardIterator __t,
3285	_UniformRandomNumberGenerator& __urng)
3286	{ this->__generate_impl(__f, __t, __urng); }
3287
3288	template<typename _ForwardIterator,
3289	typename _UniformRandomNumberGenerator>
3290	void
3291	__generate(_ForwardIterator __f, _ForwardIterator __t,
3292	_UniformRandomNumberGenerator& __urng,
3293	const param_type& __p)
3294	{ this->__generate_impl(__f, __t, __urng, __p); }
3295
3296	template<typename _UniformRandomNumberGenerator>
3297	void
3298	__generate(result_type* __f, result_type* __t,
3299	_UniformRandomNumberGenerator& __urng)
3300	{ this->__generate_impl(__f, __t, __urng); }
3301
3302	template<typename _UniformRandomNumberGenerator>
3303	void
3304	__generate(result_type* __f, result_type* __t,
3305	_UniformRandomNumberGenerator& __urng,
3306	const param_type& __p)
3307	{ this->__generate_impl(__f, __t, __urng, __p); }
3308
3309	/**
3310	* @brief Return true if two Fisher f distributions have
3311	* the same parameters and the sequences that would
3312	* be generated are equal.
3313	*/
3314	friend bool
3315	operator==(const fisher_f_distribution& __d1,
3316	const fisher_f_distribution& __d2)
3317	{ return (__d1._M_param == __d2._M_param
3318	&& __d1._M_gd_x == __d2._M_gd_x
3319	&& __d1._M_gd_y == __d2._M_gd_y); }
3320
3321	/**
3322	* @brief Inserts a %fisher_f_distribution random number distribution
3323	* @p __x into the output stream @p __os.
3324	*
3325	* @param __os An output stream.
3326	* @param __x A %fisher_f_distribution random number distribution.
3327	*
3328	* @returns The output stream with the state of @p __x inserted or in
3329	* an error state.
3330	*/
3331	template<typename _RealType1, typename _CharT, typename _Traits>
3332	friend std::basic_ostream<_CharT, _Traits>&
3333	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3334	const std::fisher_f_distribution<_RealType1>& __x);
3335
3336	/**
3337	* @brief Extracts a %fisher_f_distribution random number distribution
3338	* @p __x from the input stream @p __is.
3339	*
3340	* @param __is An input stream.
3341	* @param __x A %fisher_f_distribution random number
3342	* generator engine.
3343	*
3344	* @returns The input stream with @p __x extracted or in an error state.
3345	*/
3346	template<typename _RealType1, typename _CharT, typename _Traits>
3347	friend std::basic_istream<_CharT, _Traits>&
3348	operator>>(std::basic_istream<_CharT, _Traits>& __is,
3349	std::fisher_f_distribution<_RealType1>& __x);
3350
3351	private:
3352	template<typename _ForwardIterator,
3353	typename _UniformRandomNumberGenerator>
3354	void
3355	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3356	_UniformRandomNumberGenerator& __urng);
3357
3358	template<typename _ForwardIterator,
3359	typename _UniformRandomNumberGenerator>
3360	void
3361	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3362	_UniformRandomNumberGenerator& __urng,
3363	const param_type& __p);
3364
3365	param_type _M_param;
3366
3367	std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
3368	};
3369
3370	#if __cpp_impl_three_way_comparison < 201907L
3371	/**
3372	* @brief Return true if two Fisher f distributions are different.
3373	*/
3374	template<typename _RealType>
3375	inline bool
3376	operator!=(const std::fisher_f_distribution<_RealType>& __d1,
3377	const std::fisher_f_distribution<_RealType>& __d2)
3378	{ return !(__d1 == __d2); }
3379	#endif
3380
3381	/**
3382	* @brief A student_t_distribution random number distribution.
3383	*
3384	* The formula for the normal probability mass function is:
3385	* @f[
3386	* p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
3387	* (1 + \frac{x^2}{n}) ^{-(n+1)/2}
3388	* @f]
3389	*
3390	* @headerfile random
3391	* @since C++11
3392	*/
3393	template<typename _RealType = double>
3394	class student_t_distribution
3395	{
3396	static_assert(std::is_floating_point<_RealType>::value,
3397	"result_type must be a floating point type");
3398
3399	public:
3400	/** The type of the range of the distribution. */
3401	typedef _RealType result_type;
3402
3403	/** Parameter type. */
3404	struct param_type
3405	{
3406	typedef student_t_distribution<_RealType> distribution_type;
3407
3408	param_type() : param_type(1) { }
3409
3410	explicit
3411	param_type(_RealType __n)
3412	: _M_n(__n)
3413	{ }
3414
3415	_RealType
3416	n() const
3417	{ return _M_n; }
3418
3419	friend bool
3420	operator==(const param_type& __p1, const param_type& __p2)
3421	{ return __p1._M_n == __p2._M_n; }
3422
3423	#if __cpp_impl_three_way_comparison < 201907L
3424	friend bool
3425	operator!=(const param_type& __p1, const param_type& __p2)
3426	{ return !(__p1 == __p2); }
3427	#endif
3428
3429	private:
3430	_RealType _M_n;
3431	};
3432
3433	student_t_distribution() : student_t_distribution(1.0) { }
3434
3435	explicit
3436	student_t_distribution(_RealType __n)
3437	: _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3438	{ }
3439
3440	explicit
3441	student_t_distribution(const param_type& __p)
3442	: _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3443	{ }
3444
3445	/**
3446	* @brief Resets the distribution state.
3447	*/
3448	void
3449	reset()
3450	{
3451	_M_nd.reset();
3452	_M_gd.reset();
3453	}
3454
3455	/**
3456	*
3457	*/
3458	_RealType
3459	n() const
3460	{ return _M_param.n(); }
3461
3462	/**
3463	* @brief Returns the parameter set of the distribution.
3464	*/
3465	param_type
3466	param() const
3467	{ return _M_param; }
3468
3469	/**
3470	* @brief Sets the parameter set of the distribution.
3471	* @param __param The new parameter set of the distribution.
3472	*/
3473	void
3474	param(const param_type& __param)
3475	{ _M_param = __param; }
3476
3477	/**
3478	* @brief Returns the greatest lower bound value of the distribution.
3479	*/
3480	result_type
3481	min() const
3482	{ return std::numeric_limits<result_type>::lowest(); }
3483
3484	/**
3485	* @brief Returns the least upper bound value of the distribution.
3486	*/
3487	result_type
3488	max() const
3489	{ return std::numeric_limits<result_type>::max(); }
3490
3491	/**
3492	* @brief Generating functions.
3493	*/
3494	template<typename _UniformRandomNumberGenerator>
3495	result_type
3496	operator()(_UniformRandomNumberGenerator& __urng)
3497	{ return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
3498
3499	template<typename _UniformRandomNumberGenerator>
3500	result_type
3501	operator()(_UniformRandomNumberGenerator& __urng,
3502	const param_type& __p)
3503	{
3504	typedef typename std::gamma_distribution<result_type>::param_type
3505	param_type;
3506
3507	const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3508	return _M_nd(__urng) * std::sqrt(__p.n() / __g);
3509	}
3510
3511	template<typename _ForwardIterator,
3512	typename _UniformRandomNumberGenerator>
3513	void
3514	__generate(_ForwardIterator __f, _ForwardIterator __t,
3515	_UniformRandomNumberGenerator& __urng)
3516	{ this->__generate_impl(__f, __t, __urng); }
3517
3518	template<typename _ForwardIterator,
3519	typename _UniformRandomNumberGenerator>
3520	void
3521	__generate(_ForwardIterator __f, _ForwardIterator __t,
3522	_UniformRandomNumberGenerator& __urng,
3523	const param_type& __p)
3524	{ this->__generate_impl(__f, __t, __urng, __p); }
3525
3526	template<typename _UniformRandomNumberGenerator>
3527	void
3528	__generate(result_type* __f, result_type* __t,
3529	_UniformRandomNumberGenerator& __urng)
3530	{ this->__generate_impl(__f, __t, __urng); }
3531
3532	template<typename _UniformRandomNumberGenerator>
3533	void
3534	__generate(result_type* __f, result_type* __t,
3535	_UniformRandomNumberGenerator& __urng,
3536	const param_type& __p)
3537	{ this->__generate_impl(__f, __t, __urng, __p); }
3538
3539	/**
3540	* @brief Return true if two Student t distributions have
3541	* the same parameters and the sequences that would
3542	* be generated are equal.
3543	*/
3544	friend bool
3545	operator==(const student_t_distribution& __d1,
3546	const student_t_distribution& __d2)
3547	{ return (__d1._M_param == __d2._M_param
3548	&& __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3549
3550	/**
3551	* @brief Inserts a %student_t_distribution random number distribution
3552	* @p __x into the output stream @p __os.
3553	*
3554	* @param __os An output stream.
3555	* @param __x A %student_t_distribution random number distribution.
3556	*
3557	* @returns The output stream with the state of @p __x inserted or in
3558	* an error state.
3559	*/
3560	template<typename _RealType1, typename _CharT, typename _Traits>
3561	friend std::basic_ostream<_CharT, _Traits>&
3562	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3563	const std::student_t_distribution<_RealType1>& __x);
3564
3565	/**
3566	* @brief Extracts a %student_t_distribution random number distribution
3567	* @p __x from the input stream @p __is.
3568	*
3569	* @param __is An input stream.
3570	* @param __x A %student_t_distribution random number
3571	* generator engine.
3572	*
3573	* @returns The input stream with @p __x extracted or in an error state.
3574	*/
3575	template<typename _RealType1, typename _CharT, typename _Traits>
3576	friend std::basic_istream<_CharT, _Traits>&
3577	operator>>(std::basic_istream<_CharT, _Traits>& __is,
3578	std::student_t_distribution<_RealType1>& __x);
3579
3580	private:
3581	template<typename _ForwardIterator,
3582	typename _UniformRandomNumberGenerator>
3583	void
3584	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3585	_UniformRandomNumberGenerator& __urng);
3586	template<typename _ForwardIterator,
3587	typename _UniformRandomNumberGenerator>
3588	void
3589	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3590	_UniformRandomNumberGenerator& __urng,
3591	const param_type& __p);
3592
3593	param_type _M_param;
3594
3595	std::normal_distribution<result_type> _M_nd;
3596	std::gamma_distribution<result_type> _M_gd;
3597	};
3598
3599	#if __cpp_impl_three_way_comparison < 201907L
3600	/**
3601	* @brief Return true if two Student t distributions are different.
3602	*/
3603	template<typename _RealType>
3604	inline bool
3605	operator!=(const std::student_t_distribution<_RealType>& __d1,
3606	const std::student_t_distribution<_RealType>& __d2)
3607	{ return !(__d1 == __d2); }
3608	#endif
3609
3610	/// @} group random_distributions_normal
3611
3612	/**
3613	* @addtogroup random_distributions_bernoulli Bernoulli Distributions
3614	* @ingroup random_distributions
3615	* @{
3616	*/
3617
3618	/**
3619	* @brief A Bernoulli random number distribution.
3620	*
3621	* Generates a sequence of true and false values with likelihood @f$p@f$
3622	* that true will come up and @f$(1 - p)@f$ that false will appear.
3623	*
3624	* @headerfile random
3625	* @since C++11
3626	*/
3627	class bernoulli_distribution
3628	{
3629	public:
3630	/** The type of the range of the distribution. */
3631	typedef bool result_type;
3632
3633	/** Parameter type. */
3634	struct param_type
3635	{
3636	typedef bernoulli_distribution distribution_type;
3637
3638	param_type() : param_type(0.5) { }
3639
3640	explicit
3641	param_type(double __p)
3642	: _M_p(__p)
3643	{
3644	__glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3645	}
3646
3647	double
3648	p() const
3649	{ return _M_p; }
3650
3651	friend bool
3652	operator==(const param_type& __p1, const param_type& __p2)
3653	{ return __p1._M_p == __p2._M_p; }
3654
3655	#if __cpp_impl_three_way_comparison < 201907L
3656	friend bool
3657	operator!=(const param_type& __p1, const param_type& __p2)
3658	{ return !(__p1 == __p2); }
3659	#endif
3660
3661	private:
3662	double _M_p;
3663	};
3664
3665	public:
3666	/**
3667	* @brief Constructs a Bernoulli distribution with likelihood 0.5.
3668	*/
3669	bernoulli_distribution() : bernoulli_distribution(0.5) { }
3670
3671	/**
3672	* @brief Constructs a Bernoulli distribution with likelihood @p p.
3673	*
3674	* @param __p [IN] The likelihood of a true result being returned.
3675	* Must be in the interval @f$[0, 1]@f$.
3676	*/
3677	explicit
3678	bernoulli_distribution(double __p)
3679	: _M_param(__p)
3680	{ }
3681
3682	explicit
3683	bernoulli_distribution(const param_type& __p)
3684	: _M_param(__p)
3685	{ }
3686
3687	/**
3688	* @brief Resets the distribution state.
3689	*
3690	* Does nothing for a Bernoulli distribution.
3691	*/
3692	void
3693	reset() { }
3694
3695	/**
3696	* @brief Returns the @p p parameter of the distribution.
3697	*/
3698	double
3699	p() const
3700	{ return _M_param.p(); }
3701
3702	/**
3703	* @brief Returns the parameter set of the distribution.
3704	*/
3705	param_type
3706	param() const
3707	{ return _M_param; }
3708
3709	/**
3710	* @brief Sets the parameter set of the distribution.
3711	* @param __param The new parameter set of the distribution.
3712	*/
3713	void
3714	param(const param_type& __param)
3715	{ _M_param = __param; }
3716
3717	/**
3718	* @brief Returns the greatest lower bound value of the distribution.
3719	*/
3720	result_type
3721	min() const
3722	{ return std::numeric_limits<result_type>::min(); }
3723
3724	/**
3725	* @brief Returns the least upper bound value of the distribution.
3726	*/
3727	result_type
3728	max() const
3729	{ return std::numeric_limits<result_type>::max(); }
3730
3731	/**
3732	* @brief Generating functions.
3733	*/
3734	template<typename _UniformRandomNumberGenerator>
3735	result_type
3736	operator()(_UniformRandomNumberGenerator& __urng)
3737	{ return this->operator()(__urng, _M_param); }
3738
3739	template<typename _UniformRandomNumberGenerator>
3740	result_type
3741	operator()(_UniformRandomNumberGenerator& __urng,
3742	const param_type& __p)
3743	{
3744	__detail::_Adaptor<_UniformRandomNumberGenerator, double>
3745	__aurng(__urng);
3746	if ((__aurng() - __aurng.min())
3747	< __p.p() * (__aurng.max() - __aurng.min()))
3748	return true;
3749	return false;
3750	}
3751
3752	template<typename _ForwardIterator,
3753	typename _UniformRandomNumberGenerator>
3754	void
3755	__generate(_ForwardIterator __f, _ForwardIterator __t,
3756	_UniformRandomNumberGenerator& __urng)
3757	{ this->__generate(__f, __t, __urng, _M_param); }
3758
3759	template<typename _ForwardIterator,
3760	typename _UniformRandomNumberGenerator>
3761	void
3762	__generate(_ForwardIterator __f, _ForwardIterator __t,
3763	_UniformRandomNumberGenerator& __urng, const param_type& __p)
3764	{ this->__generate_impl(__f, __t, __urng, __p); }
3765
3766	template<typename _UniformRandomNumberGenerator>
3767	void
3768	__generate(result_type* __f, result_type* __t,
3769	_UniformRandomNumberGenerator& __urng,
3770	const param_type& __p)
3771	{ this->__generate_impl(__f, __t, __urng, __p); }
3772
3773	/**
3774	* @brief Return true if two Bernoulli distributions have
3775	* the same parameters.
3776	*/
3777	friend bool
3778	operator==(const bernoulli_distribution& __d1,
3779	const bernoulli_distribution& __d2)
3780	{ return __d1._M_param == __d2._M_param; }
3781
3782	private:
3783	template<typename _ForwardIterator,
3784	typename _UniformRandomNumberGenerator>
3785	void
3786	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3787	_UniformRandomNumberGenerator& __urng,
3788	const param_type& __p);
3789
3790	param_type _M_param;
3791	};
3792
3793	#if __cpp_impl_three_way_comparison < 201907L
3794	/**
3795	* @brief Return true if two Bernoulli distributions have
3796	* different parameters.
3797	*/
3798	inline bool
3799	operator!=(const std::bernoulli_distribution& __d1,
3800	const std::bernoulli_distribution& __d2)
3801	{ return !(__d1 == __d2); }
3802	#endif
3803
3804	/**
3805	* @brief Inserts a %bernoulli_distribution random number distribution
3806	* @p __x into the output stream @p __os.
3807	*
3808	* @param __os An output stream.
3809	* @param __x A %bernoulli_distribution random number distribution.
3810	*
3811	* @returns The output stream with the state of @p __x inserted or in
3812	* an error state.
3813	*/
3814	template<typename _CharT, typename _Traits>
3815	std::basic_ostream<_CharT, _Traits>&
3816	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3817	const std::bernoulli_distribution& __x);
3818
3819	/**
3820	* @brief Extracts a %bernoulli_distribution random number distribution
3821	* @p __x from the input stream @p __is.
3822	*
3823	* @param __is An input stream.
3824	* @param __x A %bernoulli_distribution random number generator engine.
3825	*
3826	* @returns The input stream with @p __x extracted or in an error state.
3827	*/
3828	template<typename _CharT, typename _Traits>
3829	inline std::basic_istream<_CharT, _Traits>&
3830	operator>>(std::basic_istream<_CharT, _Traits>& __is,
3831	std::bernoulli_distribution& __x)
3832	{
3833	double __p;
3834	if (__is >> __p)
3835	__x.param(param: bernoulli_distribution::param_type(__p));
3836	return __is;
3837	}
3838
3839
3840	/**
3841	* @brief A discrete binomial random number distribution.
3842	*
3843	* The formula for the binomial probability density function is
3844	* @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
3845	* and @f$p@f$ are the parameters of the distribution.
3846	*
3847	* @headerfile random
3848	* @since C++11
3849	*/
3850	template<typename _IntType = int>
3851	class binomial_distribution
3852	{
3853	static_assert(std::is_integral<_IntType>::value,
3854	"result_type must be an integral type");
3855
3856	public:
3857	/** The type of the range of the distribution. */
3858	typedef _IntType result_type;
3859
3860	/** Parameter type. */
3861	struct param_type
3862	{
3863	typedef binomial_distribution<_IntType> distribution_type;
3864	friend class binomial_distribution<_IntType>;
3865
3866	param_type() : param_type(1) { }
3867
3868	explicit
3869	param_type(_IntType __t, double __p = 0.5)
3870	: _M_t(__t), _M_p(__p)
3871	{
3872	__glibcxx_assert((_M_t >= _IntType(0))
3873	&& (_M_p >= 0.0)
3874	&& (_M_p <= 1.0));
3875	_M_initialize();
3876	}
3877
3878	_IntType
3879	t() const
3880	{ return _M_t; }
3881
3882	double
3883	p() const
3884	{ return _M_p; }
3885
3886	friend bool
3887	operator==(const param_type& __p1, const param_type& __p2)
3888	{ return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3889
3890	#if __cpp_impl_three_way_comparison < 201907L
3891	friend bool
3892	operator!=(const param_type& __p1, const param_type& __p2)
3893	{ return !(__p1 == __p2); }
3894	#endif
3895
3896	private:
3897	void
3898	_M_initialize();
3899
3900	_IntType _M_t;
3901	double _M_p;
3902
3903	double _M_q;
3904	#if _GLIBCXX_USE_C99_MATH_TR1
3905	double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3906	_M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3907	#endif
3908	bool _M_easy;
3909	};
3910
3911	// constructors and member functions
3912
3913	binomial_distribution() : binomial_distribution(1) { }
3914
3915	explicit
3916	binomial_distribution(_IntType __t, double __p = 0.5)
3917	: _M_param(__t, __p), _M_nd()
3918	{ }
3919
3920	explicit
3921	binomial_distribution(const param_type& __p)
3922	: _M_param(__p), _M_nd()
3923	{ }
3924
3925	/**
3926	* @brief Resets the distribution state.
3927	*/
3928	void
3929	reset()
3930	{ _M_nd.reset(); }
3931
3932	/**
3933	* @brief Returns the distribution @p t parameter.
3934	*/
3935	_IntType
3936	t() const
3937	{ return _M_param.t(); }
3938
3939	/**
3940	* @brief Returns the distribution @p p parameter.
3941	*/
3942	double
3943	p() const
3944	{ return _M_param.p(); }
3945
3946	/**
3947	* @brief Returns the parameter set of the distribution.
3948	*/
3949	param_type
3950	param() const
3951	{ return _M_param; }
3952
3953	/**
3954	* @brief Sets the parameter set of the distribution.
3955	* @param __param The new parameter set of the distribution.
3956	*/
3957	void
3958	param(const param_type& __param)
3959	{ _M_param = __param; }
3960
3961	/**
3962	* @brief Returns the greatest lower bound value of the distribution.
3963	*/
3964	result_type
3965	min() const
3966	{ return 0; }
3967
3968	/**
3969	* @brief Returns the least upper bound value of the distribution.
3970	*/
3971	result_type
3972	max() const
3973	{ return _M_param.t(); }
3974
3975	/**
3976	* @brief Generating functions.
3977	*/
3978	template<typename _UniformRandomNumberGenerator>
3979	result_type
3980	operator()(_UniformRandomNumberGenerator& __urng)
3981	{ return this->operator()(__urng, _M_param); }
3982
3983	template<typename _UniformRandomNumberGenerator>
3984	result_type
3985	operator()(_UniformRandomNumberGenerator& __urng,
3986	const param_type& __p);
3987
3988	template<typename _ForwardIterator,
3989	typename _UniformRandomNumberGenerator>
3990	void
3991	__generate(_ForwardIterator __f, _ForwardIterator __t,
3992	_UniformRandomNumberGenerator& __urng)
3993	{ this->__generate(__f, __t, __urng, _M_param); }
3994
3995	template<typename _ForwardIterator,
3996	typename _UniformRandomNumberGenerator>
3997	void
3998	__generate(_ForwardIterator __f, _ForwardIterator __t,
3999	_UniformRandomNumberGenerator& __urng,
4000	const param_type& __p)
4001	{ this->__generate_impl(__f, __t, __urng, __p); }
4002
4003	template<typename _UniformRandomNumberGenerator>
4004	void
4005	__generate(result_type* __f, result_type* __t,
4006	_UniformRandomNumberGenerator& __urng,
4007	const param_type& __p)
4008	{ this->__generate_impl(__f, __t, __urng, __p); }
4009
4010	/**
4011	* @brief Return true if two binomial distributions have
4012	* the same parameters and the sequences that would
4013	* be generated are equal.
4014	*/
4015	friend bool
4016	operator==(const binomial_distribution& __d1,
4017	const binomial_distribution& __d2)
4018	#ifdef _GLIBCXX_USE_C99_MATH_TR1
4019	{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4020	#else
4021	{ return __d1._M_param == __d2._M_param; }
4022	#endif
4023
4024	/**
4025	* @brief Inserts a %binomial_distribution random number distribution
4026	* @p __x into the output stream @p __os.
4027	*
4028	* @param __os An output stream.
4029	* @param __x A %binomial_distribution random number distribution.
4030	*
4031	* @returns The output stream with the state of @p __x inserted or in
4032	* an error state.
4033	*/
4034	template<typename _IntType1,
4035	typename _CharT, typename _Traits>
4036	friend std::basic_ostream<_CharT, _Traits>&
4037	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4038	const std::binomial_distribution<_IntType1>& __x);
4039
4040	/**
4041	* @brief Extracts a %binomial_distribution random number distribution
4042	* @p __x from the input stream @p __is.
4043	*
4044	* @param __is An input stream.
4045	* @param __x A %binomial_distribution random number generator engine.
4046	*
4047	* @returns The input stream with @p __x extracted or in an error
4048	* state.
4049	*/
4050	template<typename _IntType1,
4051	typename _CharT, typename _Traits>
4052	friend std::basic_istream<_CharT, _Traits>&
4053	operator>>(std::basic_istream<_CharT, _Traits>& __is,
4054	std::binomial_distribution<_IntType1>& __x);
4055
4056	private:
4057	template<typename _ForwardIterator,
4058	typename _UniformRandomNumberGenerator>
4059	void
4060	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4061	_UniformRandomNumberGenerator& __urng,
4062	const param_type& __p);
4063
4064	template<typename _UniformRandomNumberGenerator>
4065	result_type
4066	_M_waiting(_UniformRandomNumberGenerator& __urng,
4067	_IntType __t, double __q);
4068
4069	param_type _M_param;
4070
4071	// NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
4072	std::normal_distribution<double> _M_nd;
4073	};
4074
4075	#if __cpp_impl_three_way_comparison < 201907L
4076	/**
4077	* @brief Return true if two binomial distributions are different.
4078	*/
4079	template<typename _IntType>
4080	inline bool
4081	operator!=(const std::binomial_distribution<_IntType>& __d1,
4082	const std::binomial_distribution<_IntType>& __d2)
4083	{ return !(__d1 == __d2); }
4084	#endif
4085
4086	/**
4087	* @brief A discrete geometric random number distribution.
4088	*
4089	* The formula for the geometric probability density function is
4090	* @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
4091	* distribution.
4092	*
4093	* @headerfile random
4094	* @since C++11
4095	*/
4096	template<typename _IntType = int>
4097	class geometric_distribution
4098	{
4099	static_assert(std::is_integral<_IntType>::value,
4100	"result_type must be an integral type");
4101
4102	public:
4103	/** The type of the range of the distribution. */
4104	typedef _IntType result_type;
4105
4106	/** Parameter type. */
4107	struct param_type
4108	{
4109	typedef geometric_distribution<_IntType> distribution_type;
4110	friend class geometric_distribution<_IntType>;
4111
4112	param_type() : param_type(0.5) { }
4113
4114	explicit
4115	param_type(double __p)
4116	: _M_p(__p)
4117	{
4118	__glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4119	_M_initialize();
4120	}
4121
4122	double
4123	p() const
4124	{ return _M_p; }
4125
4126	friend bool
4127	operator==(const param_type& __p1, const param_type& __p2)
4128	{ return __p1._M_p == __p2._M_p; }
4129
4130	#if __cpp_impl_three_way_comparison < 201907L
4131	friend bool
4132	operator!=(const param_type& __p1, const param_type& __p2)
4133	{ return !(__p1 == __p2); }
4134	#endif
4135
4136	private:
4137	void
4138	_M_initialize()
4139	{ _M_log_1_p = std::log(x: 1.0 - _M_p); }
4140
4141	double _M_p;
4142
4143	double _M_log_1_p;
4144	};
4145
4146	// constructors and member functions
4147
4148	geometric_distribution() : geometric_distribution(0.5) { }
4149
4150	explicit
4151	geometric_distribution(double __p)
4152	: _M_param(__p)
4153	{ }
4154
4155	explicit
4156	geometric_distribution(const param_type& __p)
4157	: _M_param(__p)
4158	{ }
4159
4160	/**
4161	* @brief Resets the distribution state.
4162	*
4163	* Does nothing for the geometric distribution.
4164	*/
4165	void
4166	reset() { }
4167
4168	/**
4169	* @brief Returns the distribution parameter @p p.
4170	*/
4171	double
4172	p() const
4173	{ return _M_param.p(); }
4174
4175	/**
4176	* @brief Returns the parameter set of the distribution.
4177	*/
4178	param_type
4179	param() const
4180	{ return _M_param; }
4181
4182	/**
4183	* @brief Sets the parameter set of the distribution.
4184	* @param __param The new parameter set of the distribution.
4185	*/
4186	void
4187	param(const param_type& __param)
4188	{ _M_param = __param; }
4189
4190	/**
4191	* @brief Returns the greatest lower bound value of the distribution.
4192	*/
4193	result_type
4194	min() const
4195	{ return 0; }
4196
4197	/**
4198	* @brief Returns the least upper bound value of the distribution.
4199	*/
4200	result_type
4201	max() const
4202	{ return std::numeric_limits<result_type>::max(); }
4203
4204	/**
4205	* @brief Generating functions.
4206	*/
4207	template<typename _UniformRandomNumberGenerator>
4208	result_type
4209	operator()(_UniformRandomNumberGenerator& __urng)
4210	{ return this->operator()(__urng, _M_param); }
4211
4212	template<typename _UniformRandomNumberGenerator>
4213	result_type
4214	operator()(_UniformRandomNumberGenerator& __urng,
4215	const param_type& __p);
4216
4217	template<typename _ForwardIterator,
4218	typename _UniformRandomNumberGenerator>
4219	void
4220	__generate(_ForwardIterator __f, _ForwardIterator __t,
4221	_UniformRandomNumberGenerator& __urng)
4222	{ this->__generate(__f, __t, __urng, _M_param); }
4223
4224	template<typename _ForwardIterator,
4225	typename _UniformRandomNumberGenerator>
4226	void
4227	__generate(_ForwardIterator __f, _ForwardIterator __t,
4228	_UniformRandomNumberGenerator& __urng,
4229	const param_type& __p)
4230	{ this->__generate_impl(__f, __t, __urng, __p); }
4231
4232	template<typename _UniformRandomNumberGenerator>
4233	void
4234	__generate(result_type* __f, result_type* __t,
4235	_UniformRandomNumberGenerator& __urng,
4236	const param_type& __p)
4237	{ this->__generate_impl(__f, __t, __urng, __p); }
4238
4239	/**
4240	* @brief Return true if two geometric distributions have
4241	* the same parameters.
4242	*/
4243	friend bool
4244	operator==(const geometric_distribution& __d1,
4245	const geometric_distribution& __d2)
4246	{ return __d1._M_param == __d2._M_param; }
4247
4248	private:
4249	template<typename _ForwardIterator,
4250	typename _UniformRandomNumberGenerator>
4251	void
4252	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4253	_UniformRandomNumberGenerator& __urng,
4254	const param_type& __p);
4255
4256	param_type _M_param;
4257	};
4258
4259	#if __cpp_impl_three_way_comparison < 201907L
4260	/**
4261	* @brief Return true if two geometric distributions have
4262	* different parameters.
4263	*/
4264	template<typename _IntType>
4265	inline bool
4266	operator!=(const std::geometric_distribution<_IntType>& __d1,
4267	const std::geometric_distribution<_IntType>& __d2)
4268	{ return !(__d1 == __d2); }
4269	#endif
4270
4271	/**
4272	* @brief Inserts a %geometric_distribution random number distribution
4273	* @p __x into the output stream @p __os.
4274	*
4275	* @param __os An output stream.
4276	* @param __x A %geometric_distribution random number distribution.
4277	*
4278	* @returns The output stream with the state of @p __x inserted or in
4279	* an error state.
4280	*/
4281	template<typename _IntType,
4282	typename _CharT, typename _Traits>
4283	std::basic_ostream<_CharT, _Traits>&
4284	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4285	const std::geometric_distribution<_IntType>& __x);
4286
4287	/**
4288	* @brief Extracts a %geometric_distribution random number distribution
4289	* @p __x from the input stream @p __is.
4290	*
4291	* @param __is An input stream.
4292	* @param __x A %geometric_distribution random number generator engine.
4293	*
4294	* @returns The input stream with @p __x extracted or in an error state.
4295	*/
4296	template<typename _IntType,
4297	typename _CharT, typename _Traits>
4298	std::basic_istream<_CharT, _Traits>&
4299	operator>>(std::basic_istream<_CharT, _Traits>& __is,
4300	std::geometric_distribution<_IntType>& __x);
4301
4302
4303	/**
4304	* @brief A negative_binomial_distribution random number distribution.
4305	*
4306	* The formula for the negative binomial probability mass function is
4307	* @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
4308	* and @f$p@f$ are the parameters of the distribution.
4309	*
4310	* @headerfile random
4311	* @since C++11
4312	*/
4313	template<typename _IntType = int>
4314	class negative_binomial_distribution
4315	{
4316	static_assert(std::is_integral<_IntType>::value,
4317	"result_type must be an integral type");
4318
4319	public:
4320	/** The type of the range of the distribution. */
4321	typedef _IntType result_type;
4322
4323	/** Parameter type. */
4324	struct param_type
4325	{
4326	typedef negative_binomial_distribution<_IntType> distribution_type;
4327
4328	param_type() : param_type(1) { }
4329
4330	explicit
4331	param_type(_IntType __k, double __p = 0.5)
4332	: _M_k(__k), _M_p(__p)
4333	{
4334	__glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4335	}
4336
4337	_IntType
4338	k() const
4339	{ return _M_k; }
4340
4341	double
4342	p() const
4343	{ return _M_p; }
4344
4345	friend bool
4346	operator==(const param_type& __p1, const param_type& __p2)
4347	{ return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4348
4349	#if __cpp_impl_three_way_comparison < 201907L
4350	friend bool
4351	operator!=(const param_type& __p1, const param_type& __p2)
4352	{ return !(__p1 == __p2); }
4353	#endif
4354
4355	private:
4356	_IntType _M_k;
4357	double _M_p;
4358	};
4359
4360	negative_binomial_distribution() : negative_binomial_distribution(1) { }
4361
4362	explicit
4363	negative_binomial_distribution(_IntType __k, double __p = 0.5)
4364	: _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4365	{ }
4366
4367	explicit
4368	negative_binomial_distribution(const param_type& __p)
4369	: _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
4370	{ }
4371
4372	/**
4373	* @brief Resets the distribution state.
4374	*/
4375	void
4376	reset()
4377	{ _M_gd.reset(); }
4378
4379	/**
4380	* @brief Return the @f$k@f$ parameter of the distribution.
4381	*/
4382	_IntType
4383	k() const
4384	{ return _M_param.k(); }
4385
4386	/**
4387	* @brief Return the @f$p@f$ parameter of the distribution.
4388	*/
4389	double
4390	p() const
4391	{ return _M_param.p(); }
4392
4393	/**
4394	* @brief Returns the parameter set of the distribution.
4395	*/
4396	param_type
4397	param() const
4398	{ return _M_param; }
4399
4400	/**
4401	* @brief Sets the parameter set of the distribution.
4402	* @param __param The new parameter set of the distribution.
4403	*/
4404	void
4405	param(const param_type& __param)
4406	{ _M_param = __param; }
4407
4408	/**
4409	* @brief Returns the greatest lower bound value of the distribution.
4410	*/
4411	result_type
4412	min() const
4413	{ return result_type(0); }
4414
4415	/**
4416	* @brief Returns the least upper bound value of the distribution.
4417	*/
4418	result_type
4419	max() const
4420	{ return std::numeric_limits<result_type>::max(); }
4421
4422	/**
4423	* @brief Generating functions.
4424	*/
4425	template<typename _UniformRandomNumberGenerator>
4426	result_type
4427	operator()(_UniformRandomNumberGenerator& __urng);
4428
4429	template<typename _UniformRandomNumberGenerator>
4430	result_type
4431	operator()(_UniformRandomNumberGenerator& __urng,
4432	const param_type& __p);
4433
4434	template<typename _ForwardIterator,
4435	typename _UniformRandomNumberGenerator>
4436	void
4437	__generate(_ForwardIterator __f, _ForwardIterator __t,
4438	_UniformRandomNumberGenerator& __urng)
4439	{ this->__generate_impl(__f, __t, __urng); }
4440
4441	template<typename _ForwardIterator,
4442	typename _UniformRandomNumberGenerator>
4443	void
4444	__generate(_ForwardIterator __f, _ForwardIterator __t,
4445	_UniformRandomNumberGenerator& __urng,
4446	const param_type& __p)
4447	{ this->__generate_impl(__f, __t, __urng, __p); }
4448
4449	template<typename _UniformRandomNumberGenerator>
4450	void
4451	__generate(result_type* __f, result_type* __t,
4452	_UniformRandomNumberGenerator& __urng)
4453	{ this->__generate_impl(__f, __t, __urng); }
4454
4455	template<typename _UniformRandomNumberGenerator>
4456	void
4457	__generate(result_type* __f, result_type* __t,
4458	_UniformRandomNumberGenerator& __urng,
4459	const param_type& __p)
4460	{ this->__generate_impl(__f, __t, __urng, __p); }
4461
4462	/**
4463	* @brief Return true if two negative binomial distributions have
4464	* the same parameters and the sequences that would be
4465	* generated are equal.
4466	*/
4467	friend bool
4468	operator==(const negative_binomial_distribution& __d1,
4469	const negative_binomial_distribution& __d2)
4470	{ return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4471
4472	/**
4473	* @brief Inserts a %negative_binomial_distribution random
4474	* number distribution @p __x into the output stream @p __os.
4475	*
4476	* @param __os An output stream.
4477	* @param __x A %negative_binomial_distribution random number
4478	* distribution.
4479	*
4480	* @returns The output stream with the state of @p __x inserted or in
4481	* an error state.
4482	*/
4483	template<typename _IntType1, typename _CharT, typename _Traits>
4484	friend std::basic_ostream<_CharT, _Traits>&
4485	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4486	const std::negative_binomial_distribution<_IntType1>& __x);
4487
4488	/**
4489	* @brief Extracts a %negative_binomial_distribution random number
4490	* distribution @p __x from the input stream @p __is.
4491	*
4492	* @param __is An input stream.
4493	* @param __x A %negative_binomial_distribution random number
4494	* generator engine.
4495	*
4496	* @returns The input stream with @p __x extracted or in an error state.
4497	*/
4498	template<typename _IntType1, typename _CharT, typename _Traits>
4499	friend std::basic_istream<_CharT, _Traits>&
4500	operator>>(std::basic_istream<_CharT, _Traits>& __is,
4501	std::negative_binomial_distribution<_IntType1>& __x);
4502
4503	private:
4504	template<typename _ForwardIterator,
4505	typename _UniformRandomNumberGenerator>
4506	void
4507	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4508	_UniformRandomNumberGenerator& __urng);
4509	template<typename _ForwardIterator,
4510	typename _UniformRandomNumberGenerator>
4511	void
4512	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4513	_UniformRandomNumberGenerator& __urng,
4514	const param_type& __p);
4515
4516	param_type _M_param;
4517
4518	std::gamma_distribution<double> _M_gd;
4519	};
4520
4521	#if __cpp_impl_three_way_comparison < 201907L
4522	/**
4523	* @brief Return true if two negative binomial distributions are different.
4524	*/
4525	template<typename _IntType>
4526	inline bool
4527	operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
4528	const std::negative_binomial_distribution<_IntType>& __d2)
4529	{ return !(__d1 == __d2); }
4530	#endif
4531
4532	/// @} group random_distributions_bernoulli
4533
4534	/**
4535	* @addtogroup random_distributions_poisson Poisson Distributions
4536	* @ingroup random_distributions
4537	* @{
4538	*/
4539
4540	/**
4541	* @brief A discrete Poisson random number distribution.
4542	*
4543	* The formula for the Poisson probability density function is
4544	* @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
4545	* parameter of the distribution.
4546	*
4547	* @headerfile random
4548	* @since C++11
4549	*/
4550	template<typename _IntType = int>
4551	class poisson_distribution
4552	{
4553	static_assert(std::is_integral<_IntType>::value,
4554	"result_type must be an integral type");
4555
4556	public:
4557	/** The type of the range of the distribution. */
4558	typedef _IntType result_type;
4559
4560	/** Parameter type. */
4561	struct param_type
4562	{
4563	typedef poisson_distribution<_IntType> distribution_type;
4564	friend class poisson_distribution<_IntType>;
4565
4566	param_type() : param_type(1.0) { }
4567
4568	explicit
4569	param_type(double __mean)
4570	: _M_mean(__mean)
4571	{
4572	__glibcxx_assert(_M_mean > 0.0);
4573	_M_initialize();
4574	}
4575
4576	double
4577	mean() const
4578	{ return _M_mean; }
4579
4580	friend bool
4581	operator==(const param_type& __p1, const param_type& __p2)
4582	{ return __p1._M_mean == __p2._M_mean; }
4583
4584	#if __cpp_impl_three_way_comparison < 201907L
4585	friend bool
4586	operator!=(const param_type& __p1, const param_type& __p2)
4587	{ return !(__p1 == __p2); }
4588	#endif
4589
4590	private:
4591	// Hosts either log(mean) or the threshold of the simple method.
4592	void
4593	_M_initialize();
4594
4595	double _M_mean;
4596
4597	double _M_lm_thr;
4598	#if _GLIBCXX_USE_C99_MATH_TR1
4599	double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4600	#endif
4601	};
4602
4603	// constructors and member functions
4604
4605	poisson_distribution() : poisson_distribution(1.0) { }
4606
4607	explicit
4608	poisson_distribution(double __mean)
4609	: _M_param(__mean), _M_nd()
4610	{ }
4611
4612	explicit
4613	poisson_distribution(const param_type& __p)
4614	: _M_param(__p), _M_nd()
4615	{ }
4616
4617	/**
4618	* @brief Resets the distribution state.
4619	*/
4620	void
4621	reset()
4622	{ _M_nd.reset(); }
4623
4624	/**
4625	* @brief Returns the distribution parameter @p mean.
4626	*/
4627	double
4628	mean() const
4629	{ return _M_param.mean(); }
4630
4631	/**
4632	* @brief Returns the parameter set of the distribution.
4633	*/
4634	param_type
4635	param() const
4636	{ return _M_param; }
4637
4638	/**
4639	* @brief Sets the parameter set of the distribution.
4640	* @param __param The new parameter set of the distribution.
4641	*/
4642	void
4643	param(const param_type& __param)
4644	{ _M_param = __param; }
4645
4646	/**
4647	* @brief Returns the greatest lower bound value of the distribution.
4648	*/
4649	result_type
4650	min() const
4651	{ return 0; }
4652
4653	/**
4654	* @brief Returns the least upper bound value of the distribution.
4655	*/
4656	result_type
4657	max() const
4658	{ return std::numeric_limits<result_type>::max(); }
4659
4660	/**
4661	* @brief Generating functions.
4662	*/
4663	template<typename _UniformRandomNumberGenerator>
4664	result_type
4665	operator()(_UniformRandomNumberGenerator& __urng)
4666	{ return this->operator()(__urng, _M_param); }
4667
4668	template<typename _UniformRandomNumberGenerator>
4669	result_type
4670	operator()(_UniformRandomNumberGenerator& __urng,
4671	const param_type& __p);
4672
4673	template<typename _ForwardIterator,
4674	typename _UniformRandomNumberGenerator>
4675	void
4676	__generate(_ForwardIterator __f, _ForwardIterator __t,
4677	_UniformRandomNumberGenerator& __urng)
4678	{ this->__generate(__f, __t, __urng, _M_param); }
4679
4680	template<typename _ForwardIterator,
4681	typename _UniformRandomNumberGenerator>
4682	void
4683	__generate(_ForwardIterator __f, _ForwardIterator __t,
4684	_UniformRandomNumberGenerator& __urng,
4685	const param_type& __p)
4686	{ this->__generate_impl(__f, __t, __urng, __p); }
4687
4688	template<typename _UniformRandomNumberGenerator>
4689	void
4690	__generate(result_type* __f, result_type* __t,
4691	_UniformRandomNumberGenerator& __urng,
4692	const param_type& __p)
4693	{ this->__generate_impl(__f, __t, __urng, __p); }
4694
4695	/**
4696	* @brief Return true if two Poisson distributions have the same
4697	* parameters and the sequences that would be generated
4698	* are equal.
4699	*/
4700	friend bool
4701	operator==(const poisson_distribution& __d1,
4702	const poisson_distribution& __d2)
4703	#ifdef _GLIBCXX_USE_C99_MATH_TR1
4704	{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4705	#else
4706	{ return __d1._M_param == __d2._M_param; }
4707	#endif
4708
4709	/**
4710	* @brief Inserts a %poisson_distribution random number distribution
4711	* @p __x into the output stream @p __os.
4712	*
4713	* @param __os An output stream.
4714	* @param __x A %poisson_distribution random number distribution.
4715	*
4716	* @returns The output stream with the state of @p __x inserted or in
4717	* an error state.
4718	*/
4719	template<typename _IntType1, typename _CharT, typename _Traits>
4720	friend std::basic_ostream<_CharT, _Traits>&
4721	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4722	const std::poisson_distribution<_IntType1>& __x);
4723
4724	/**
4725	* @brief Extracts a %poisson_distribution random number distribution
4726	* @p __x from the input stream @p __is.
4727	*
4728	* @param __is An input stream.
4729	* @param __x A %poisson_distribution random number generator engine.
4730	*
4731	* @returns The input stream with @p __x extracted or in an error
4732	* state.
4733	*/
4734	template<typename _IntType1, typename _CharT, typename _Traits>
4735	friend std::basic_istream<_CharT, _Traits>&
4736	operator>>(std::basic_istream<_CharT, _Traits>& __is,
4737	std::poisson_distribution<_IntType1>& __x);
4738
4739	private:
4740	template<typename _ForwardIterator,
4741	typename _UniformRandomNumberGenerator>
4742	void
4743	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4744	_UniformRandomNumberGenerator& __urng,
4745	const param_type& __p);
4746
4747	param_type _M_param;
4748
4749	// NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
4750	std::normal_distribution<double> _M_nd;
4751	};
4752
4753	#if __cpp_impl_three_way_comparison < 201907L
4754	/**
4755	* @brief Return true if two Poisson distributions are different.
4756	*/
4757	template<typename _IntType>
4758	inline bool
4759	operator!=(const std::poisson_distribution<_IntType>& __d1,
4760	const std::poisson_distribution<_IntType>& __d2)
4761	{ return !(__d1 == __d2); }
4762	#endif
4763
4764	/**
4765	* @brief An exponential continuous distribution for random numbers.
4766	*
4767	* The formula for the exponential probability density function is
4768	* @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
4769	*
4770	* <table border=1 cellpadding=10 cellspacing=0>
4771	* <caption align=top>Distribution Statistics</caption>
4772	* <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4773	* <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
4774	* <tr><td>Mode</td><td>@f$zero@f$</td></tr>
4775	* <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
4776	* <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4777	* </table>
4778	*
4779	* @headerfile random
4780	* @since C++11
4781	*/
4782	template<typename _RealType = double>
4783	class exponential_distribution
4784	{
4785	static_assert(std::is_floating_point<_RealType>::value,
4786	"result_type must be a floating point type");
4787
4788	public:
4789	/** The type of the range of the distribution. */
4790	typedef _RealType result_type;
4791
4792	/** Parameter type. */
4793	struct param_type
4794	{
4795	typedef exponential_distribution<_RealType> distribution_type;
4796
4797	param_type() : param_type(1.0) { }
4798
4799	explicit
4800	param_type(_RealType __lambda)
4801	: _M_lambda(__lambda)
4802	{
4803	__glibcxx_assert(_M_lambda > _RealType(0));
4804	}
4805
4806	_RealType
4807	lambda() const
4808	{ return _M_lambda; }
4809
4810	friend bool
4811	operator==(const param_type& __p1, const param_type& __p2)
4812	{ return __p1._M_lambda == __p2._M_lambda; }
4813
4814	#if __cpp_impl_three_way_comparison < 201907L
4815	friend bool
4816	operator!=(const param_type& __p1, const param_type& __p2)
4817	{ return !(__p1 == __p2); }
4818	#endif
4819
4820	private:
4821	_RealType _M_lambda;
4822	};
4823
4824	public:
4825	/**
4826	* @brief Constructs an exponential distribution with inverse scale
4827	* parameter 1.0
4828	*/
4829	exponential_distribution() : exponential_distribution(1.0) { }
4830
4831	/**
4832	* @brief Constructs an exponential distribution with inverse scale
4833	* parameter @f$\lambda@f$.
4834	*/
4835	explicit
4836	exponential_distribution(_RealType __lambda)
4837	: _M_param(__lambda)
4838	{ }
4839
4840	explicit
4841	exponential_distribution(const param_type& __p)
4842	: _M_param(__p)
4843	{ }
4844
4845	/**
4846	* @brief Resets the distribution state.
4847	*
4848	* Has no effect on exponential distributions.
4849	*/
4850	void
4851	reset() { }
4852
4853	/**
4854	* @brief Returns the inverse scale parameter of the distribution.
4855	*/
4856	_RealType
4857	lambda() const
4858	{ return _M_param.lambda(); }
4859
4860	/**
4861	* @brief Returns the parameter set of the distribution.
4862	*/
4863	param_type
4864	param() const
4865	{ return _M_param; }
4866
4867	/**
4868	* @brief Sets the parameter set of the distribution.
4869	* @param __param The new parameter set of the distribution.
4870	*/
4871	void
4872	param(const param_type& __param)
4873	{ _M_param = __param; }
4874
4875	/**
4876	* @brief Returns the greatest lower bound value of the distribution.
4877	*/
4878	result_type
4879	min() const
4880	{ return result_type(0); }
4881
4882	/**
4883	* @brief Returns the least upper bound value of the distribution.
4884	*/
4885	result_type
4886	max() const
4887	{ return std::numeric_limits<result_type>::max(); }
4888
4889	/**
4890	* @brief Generating functions.
4891	*/
4892	template<typename _UniformRandomNumberGenerator>
4893	result_type
4894	operator()(_UniformRandomNumberGenerator& __urng)
4895	{ return this->operator()(__urng, _M_param); }
4896
4897	template<typename _UniformRandomNumberGenerator>
4898	result_type
4899	operator()(_UniformRandomNumberGenerator& __urng,
4900	const param_type& __p)
4901	{
4902	__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4903	__aurng(__urng);
4904	return -std::log(result_type(1) - __aurng()) / __p.lambda();
4905	}
4906
4907	template<typename _ForwardIterator,
4908	typename _UniformRandomNumberGenerator>
4909	void
4910	__generate(_ForwardIterator __f, _ForwardIterator __t,
4911	_UniformRandomNumberGenerator& __urng)
4912	{ this->__generate(__f, __t, __urng, _M_param); }
4913
4914	template<typename _ForwardIterator,
4915	typename _UniformRandomNumberGenerator>
4916	void
4917	__generate(_ForwardIterator __f, _ForwardIterator __t,
4918	_UniformRandomNumberGenerator& __urng,
4919	const param_type& __p)
4920	{ this->__generate_impl(__f, __t, __urng, __p); }
4921
4922	template<typename _UniformRandomNumberGenerator>
4923	void
4924	__generate(result_type* __f, result_type* __t,
4925	_UniformRandomNumberGenerator& __urng,
4926	const param_type& __p)
4927	{ this->__generate_impl(__f, __t, __urng, __p); }
4928
4929	/**
4930	* @brief Return true if two exponential distributions have the same
4931	* parameters.
4932	*/
4933	friend bool
4934	operator==(const exponential_distribution& __d1,
4935	const exponential_distribution& __d2)
4936	{ return __d1._M_param == __d2._M_param; }
4937
4938	private:
4939	template<typename _ForwardIterator,
4940	typename _UniformRandomNumberGenerator>
4941	void
4942	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4943	_UniformRandomNumberGenerator& __urng,
4944	const param_type& __p);
4945
4946	param_type _M_param;
4947	};
4948
4949	#if __cpp_impl_three_way_comparison < 201907L
4950	/**
4951	* @brief Return true if two exponential distributions have different
4952	* parameters.
4953	*/
4954	template<typename _RealType>
4955	inline bool
4956	operator!=(const std::exponential_distribution<_RealType>& __d1,
4957	const std::exponential_distribution<_RealType>& __d2)
4958	{ return !(__d1 == __d2); }
4959	#endif
4960
4961	/**
4962	* @brief Inserts a %exponential_distribution random number distribution
4963	* @p __x into the output stream @p __os.
4964	*
4965	* @param __os An output stream.
4966	* @param __x A %exponential_distribution random number distribution.
4967	*
4968	* @returns The output stream with the state of @p __x inserted or in
4969	* an error state.
4970	*/
4971	template<typename _RealType, typename _CharT, typename _Traits>
4972	std::basic_ostream<_CharT, _Traits>&
4973	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4974	const std::exponential_distribution<_RealType>& __x);
4975
4976	/**
4977	* @brief Extracts a %exponential_distribution random number distribution
4978	* @p __x from the input stream @p __is.
4979	*
4980	* @param __is An input stream.
4981	* @param __x A %exponential_distribution random number
4982	* generator engine.
4983	*
4984	* @returns The input stream with @p __x extracted or in an error state.
4985	*/
4986	template<typename _RealType, typename _CharT, typename _Traits>
4987	std::basic_istream<_CharT, _Traits>&
4988	operator>>(std::basic_istream<_CharT, _Traits>& __is,
4989	std::exponential_distribution<_RealType>& __x);
4990
4991
4992	/**
4993	* @brief A weibull_distribution random number distribution.
4994	*
4995	* The formula for the normal probability density function is:
4996	* @f[
4997	* p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
4998	* \exp{(-(\frac{x}{\beta})^\alpha)}
4999	* @f]
5000	*
5001	* @headerfile random
5002	* @since C++11
5003	*/
5004	template<typename _RealType = double>
5005	class weibull_distribution
5006	{
5007	static_assert(std::is_floating_point<_RealType>::value,
5008	"result_type must be a floating point type");
5009
5010	public:
5011	/** The type of the range of the distribution. */
5012	typedef _RealType result_type;
5013
5014	/** Parameter type. */
5015	struct param_type
5016	{
5017	typedef weibull_distribution<_RealType> distribution_type;
5018
5019	param_type() : param_type(1.0) { }
5020
5021	explicit
5022	param_type(_RealType __a, _RealType __b = _RealType(1.0))
5023	: _M_a(__a), _M_b(__b)
5024	{ }
5025
5026	_RealType
5027	a() const
5028	{ return _M_a; }
5029
5030	_RealType
5031	b() const
5032	{ return _M_b; }
5033
5034	friend bool
5035	operator==(const param_type& __p1, const param_type& __p2)
5036	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5037
5038	#if __cpp_impl_three_way_comparison < 201907L
5039	friend bool
5040	operator!=(const param_type& __p1, const param_type& __p2)
5041	{ return !(__p1 == __p2); }
5042	#endif
5043
5044	private:
5045	_RealType _M_a;
5046	_RealType _M_b;
5047	};
5048
5049	weibull_distribution() : weibull_distribution(1.0) { }
5050
5051	explicit
5052	weibull_distribution(_RealType __a, _RealType __b = _RealType(1))
5053	: _M_param(__a, __b)
5054	{ }
5055
5056	explicit
5057	weibull_distribution(const param_type& __p)
5058	: _M_param(__p)
5059	{ }
5060
5061	/**
5062	* @brief Resets the distribution state.
5063	*/
5064	void
5065	reset()
5066	{ }
5067
5068	/**
5069	* @brief Return the @f$a@f$ parameter of the distribution.
5070	*/
5071	_RealType
5072	a() const
5073	{ return _M_param.a(); }
5074
5075	/**
5076	* @brief Return the @f$b@f$ parameter of the distribution.
5077	*/
5078	_RealType
5079	b() const
5080	{ return _M_param.b(); }
5081
5082	/**
5083	* @brief Returns the parameter set of the distribution.
5084	*/
5085	param_type
5086	param() const
5087	{ return _M_param; }
5088
5089	/**
5090	* @brief Sets the parameter set of the distribution.
5091	* @param __param The new parameter set of the distribution.
5092	*/
5093	void
5094	param(const param_type& __param)
5095	{ _M_param = __param; }
5096
5097	/**
5098	* @brief Returns the greatest lower bound value of the distribution.
5099	*/
5100	result_type
5101	min() const
5102	{ return result_type(0); }
5103
5104	/**
5105	* @brief Returns the least upper bound value of the distribution.
5106	*/
5107	result_type
5108	max() const
5109	{ return std::numeric_limits<result_type>::max(); }
5110
5111	/**
5112	* @brief Generating functions.
5113	*/
5114	template<typename _UniformRandomNumberGenerator>
5115	result_type
5116	operator()(_UniformRandomNumberGenerator& __urng)
5117	{ return this->operator()(__urng, _M_param); }
5118
5119	template<typename _UniformRandomNumberGenerator>
5120	result_type
5121	operator()(_UniformRandomNumberGenerator& __urng,
5122	const param_type& __p);
5123
5124	template<typename _ForwardIterator,
5125	typename _UniformRandomNumberGenerator>
5126	void
5127	__generate(_ForwardIterator __f, _ForwardIterator __t,
5128	_UniformRandomNumberGenerator& __urng)
5129	{ this->__generate(__f, __t, __urng, _M_param); }
5130
5131	template<typename _ForwardIterator,
5132	typename _UniformRandomNumberGenerator>
5133	void
5134	__generate(_ForwardIterator __f, _ForwardIterator __t,
5135	_UniformRandomNumberGenerator& __urng,
5136	const param_type& __p)
5137	{ this->__generate_impl(__f, __t, __urng, __p); }
5138
5139	template<typename _UniformRandomNumberGenerator>
5140	void
5141	__generate(result_type* __f, result_type* __t,
5142	_UniformRandomNumberGenerator& __urng,
5143	const param_type& __p)
5144	{ this->__generate_impl(__f, __t, __urng, __p); }
5145
5146	/**
5147	* @brief Return true if two Weibull distributions have the same
5148	* parameters.
5149	*/
5150	friend bool
5151	operator==(const weibull_distribution& __d1,
5152	const weibull_distribution& __d2)
5153	{ return __d1._M_param == __d2._M_param; }
5154
5155	private:
5156	template<typename _ForwardIterator,
5157	typename _UniformRandomNumberGenerator>
5158	void
5159	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5160	_UniformRandomNumberGenerator& __urng,
5161	const param_type& __p);
5162
5163	param_type _M_param;
5164	};
5165
5166	#if __cpp_impl_three_way_comparison < 201907L
5167	/**
5168	* @brief Return true if two Weibull distributions have different
5169	* parameters.
5170	*/
5171	template<typename _RealType>
5172	inline bool
5173	operator!=(const std::weibull_distribution<_RealType>& __d1,
5174	const std::weibull_distribution<_RealType>& __d2)
5175	{ return !(__d1 == __d2); }
5176	#endif
5177
5178	/**
5179	* @brief Inserts a %weibull_distribution random number distribution
5180	* @p __x into the output stream @p __os.
5181	*
5182	* @param __os An output stream.
5183	* @param __x A %weibull_distribution random number distribution.
5184	*
5185	* @returns The output stream with the state of @p __x inserted or in
5186	* an error state.
5187	*/
5188	template<typename _RealType, typename _CharT, typename _Traits>
5189	std::basic_ostream<_CharT, _Traits>&
5190	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5191	const std::weibull_distribution<_RealType>& __x);
5192
5193	/**
5194	* @brief Extracts a %weibull_distribution random number distribution
5195	* @p __x from the input stream @p __is.
5196	*
5197	* @param __is An input stream.
5198	* @param __x A %weibull_distribution random number
5199	* generator engine.
5200	*
5201	* @returns The input stream with @p __x extracted or in an error state.
5202	*/
5203	template<typename _RealType, typename _CharT, typename _Traits>
5204	std::basic_istream<_CharT, _Traits>&
5205	operator>>(std::basic_istream<_CharT, _Traits>& __is,
5206	std::weibull_distribution<_RealType>& __x);
5207
5208
5209	/**
5210	* @brief A extreme_value_distribution random number distribution.
5211	*
5212	* The formula for the normal probability mass function is
5213	* @f[
5214	* p(x|a,b) = \frac{1}{b}
5215	* \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
5216	* @f]
5217	*
5218	* @headerfile random
5219	* @since C++11
5220	*/
5221	template<typename _RealType = double>
5222	class extreme_value_distribution
5223	{
5224	static_assert(std::is_floating_point<_RealType>::value,
5225	"result_type must be a floating point type");
5226
5227	public:
5228	/** The type of the range of the distribution. */
5229	typedef _RealType result_type;
5230
5231	/** Parameter type. */
5232	struct param_type
5233	{
5234	typedef extreme_value_distribution<_RealType> distribution_type;
5235
5236	param_type() : param_type(0.0) { }
5237
5238	explicit
5239	param_type(_RealType __a, _RealType __b = _RealType(1.0))
5240	: _M_a(__a), _M_b(__b)
5241	{ }
5242
5243	_RealType
5244	a() const
5245	{ return _M_a; }
5246
5247	_RealType
5248	b() const
5249	{ return _M_b; }
5250
5251	friend bool
5252	operator==(const param_type& __p1, const param_type& __p2)
5253	{ return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5254
5255	#if __cpp_impl_three_way_comparison < 201907L
5256	friend bool
5257	operator!=(const param_type& __p1, const param_type& __p2)
5258	{ return !(__p1 == __p2); }
5259	#endif
5260
5261	private:
5262	_RealType _M_a;
5263	_RealType _M_b;
5264	};
5265
5266	extreme_value_distribution() : extreme_value_distribution(0.0) { }
5267
5268	explicit
5269	extreme_value_distribution(_RealType __a, _RealType __b = _RealType(1))
5270	: _M_param(__a, __b)
5271	{ }
5272
5273	explicit
5274	extreme_value_distribution(const param_type& __p)
5275	: _M_param(__p)
5276	{ }
5277
5278	/**
5279	* @brief Resets the distribution state.
5280	*/
5281	void
5282	reset()
5283	{ }
5284
5285	/**
5286	* @brief Return the @f$a@f$ parameter of the distribution.
5287	*/
5288	_RealType
5289	a() const
5290	{ return _M_param.a(); }
5291
5292	/**
5293	* @brief Return the @f$b@f$ parameter of the distribution.
5294	*/
5295	_RealType
5296	b() const
5297	{ return _M_param.b(); }
5298
5299	/**
5300	* @brief Returns the parameter set of the distribution.
5301	*/
5302	param_type
5303	param() const
5304	{ return _M_param; }
5305
5306	/**
5307	* @brief Sets the parameter set of the distribution.
5308	* @param __param The new parameter set of the distribution.
5309	*/
5310	void
5311	param(const param_type& __param)
5312	{ _M_param = __param; }
5313
5314	/**
5315	* @brief Returns the greatest lower bound value of the distribution.
5316	*/
5317	result_type
5318	min() const
5319	{ return std::numeric_limits<result_type>::lowest(); }
5320
5321	/**
5322	* @brief Returns the least upper bound value of the distribution.
5323	*/
5324	result_type
5325	max() const
5326	{ return std::numeric_limits<result_type>::max(); }
5327
5328	/**
5329	* @brief Generating functions.
5330	*/
5331	template<typename _UniformRandomNumberGenerator>
5332	result_type
5333	operator()(_UniformRandomNumberGenerator& __urng)
5334	{ return this->operator()(__urng, _M_param); }
5335
5336	template<typename _UniformRandomNumberGenerator>
5337	result_type
5338	operator()(_UniformRandomNumberGenerator& __urng,
5339	const param_type& __p);
5340
5341	template<typename _ForwardIterator,
5342	typename _UniformRandomNumberGenerator>
5343	void
5344	__generate(_ForwardIterator __f, _ForwardIterator __t,
5345	_UniformRandomNumberGenerator& __urng)
5346	{ this->__generate(__f, __t, __urng, _M_param); }
5347
5348	template<typename _ForwardIterator,
5349	typename _UniformRandomNumberGenerator>
5350	void
5351	__generate(_ForwardIterator __f, _ForwardIterator __t,
5352	_UniformRandomNumberGenerator& __urng,
5353	const param_type& __p)
5354	{ this->__generate_impl(__f, __t, __urng, __p); }
5355
5356	template<typename _UniformRandomNumberGenerator>
5357	void
5358	__generate(result_type* __f, result_type* __t,
5359	_UniformRandomNumberGenerator& __urng,
5360	const param_type& __p)
5361	{ this->__generate_impl(__f, __t, __urng, __p); }
5362
5363	/**
5364	* @brief Return true if two extreme value distributions have the same
5365	* parameters.
5366	*/
5367	friend bool
5368	operator==(const extreme_value_distribution& __d1,
5369	const extreme_value_distribution& __d2)
5370	{ return __d1._M_param == __d2._M_param; }
5371
5372	private:
5373	template<typename _ForwardIterator,
5374	typename _UniformRandomNumberGenerator>
5375	void
5376	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5377	_UniformRandomNumberGenerator& __urng,
5378	const param_type& __p);
5379
5380	param_type _M_param;
5381	};
5382
5383	#if __cpp_impl_three_way_comparison < 201907L
5384	/**
5385	* @brief Return true if two extreme value distributions have different
5386	* parameters.
5387	*/
5388	template<typename _RealType>
5389	inline bool
5390	operator!=(const std::extreme_value_distribution<_RealType>& __d1,
5391	const std::extreme_value_distribution<_RealType>& __d2)
5392	{ return !(__d1 == __d2); }
5393	#endif
5394
5395	/**
5396	* @brief Inserts a %extreme_value_distribution random number distribution
5397	* @p __x into the output stream @p __os.
5398	*
5399	* @param __os An output stream.
5400	* @param __x A %extreme_value_distribution random number distribution.
5401	*
5402	* @returns The output stream with the state of @p __x inserted or in
5403	* an error state.
5404	*/
5405	template<typename _RealType, typename _CharT, typename _Traits>
5406	std::basic_ostream<_CharT, _Traits>&
5407	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5408	const std::extreme_value_distribution<_RealType>& __x);
5409
5410	/**
5411	* @brief Extracts a %extreme_value_distribution random number
5412	* distribution @p __x from the input stream @p __is.
5413	*
5414	* @param __is An input stream.
5415	* @param __x A %extreme_value_distribution random number
5416	* generator engine.
5417	*
5418	* @returns The input stream with @p __x extracted or in an error state.
5419	*/
5420	template<typename _RealType, typename _CharT, typename _Traits>
5421	std::basic_istream<_CharT, _Traits>&
5422	operator>>(std::basic_istream<_CharT, _Traits>& __is,
5423	std::extreme_value_distribution<_RealType>& __x);
5424
5425	/// @} group random_distributions_poisson
5426
5427	/**
5428	* @addtogroup random_distributions_sampling Sampling Distributions
5429	* @ingroup random_distributions
5430	* @{
5431	*/
5432
5433	/**
5434	* @brief A discrete_distribution random number distribution.
5435	*
5436	* This distribution produces random numbers @f$ i, 0 \leq i < n @f$,
5437	* distributed according to the probability mass function
5438	* @f$ p(i | p_0, ..., p_{n-1}) = p_i @f$.
5439	*
5440	* @headerfile random
5441	* @since C++11
5442	*/
5443	template<typename _IntType = int>
5444	class discrete_distribution
5445	{
5446	static_assert(std::is_integral<_IntType>::value,
5447	"result_type must be an integral type");
5448
5449	public:
5450	/** The type of the range of the distribution. */
5451	typedef _IntType result_type;
5452
5453	/** Parameter type. */
5454	struct param_type
5455	{
5456	typedef discrete_distribution<_IntType> distribution_type;
5457	friend class discrete_distribution<_IntType>;
5458
5459	param_type()
5460	: _M_prob(), _M_cp()
5461	{ }
5462
5463	template<typename _InputIterator>
5464	param_type(_InputIterator __wbegin,
5465	_InputIterator __wend)
5466	: _M_prob(__wbegin, __wend), _M_cp()
5467	{ _M_initialize(); }
5468
5469	param_type(initializer_list<double> __wil)
5470	: _M_prob(__wil.begin(), __wil.end()), _M_cp()
5471	{ _M_initialize(); }
5472
5473	template<typename _Func>
5474	param_type(size_t __nw, double __xmin, double __xmax,
5475	_Func __fw);
5476
5477	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5478	param_type(const param_type&) = default;
5479	param_type& operator=(const param_type&) = default;
5480
5481	std::vector<double>
5482	probabilities() const
5483	{ return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
5484
5485	friend bool
5486	operator==(const param_type& __p1, const param_type& __p2)
5487	{ return __p1._M_prob == __p2._M_prob; }
5488
5489	#if __cpp_impl_three_way_comparison < 201907L
5490	friend bool
5491	operator!=(const param_type& __p1, const param_type& __p2)
5492	{ return !(__p1 == __p2); }
5493	#endif
5494
5495	private:
5496	void
5497	_M_initialize();
5498
5499	std::vector<double> _M_prob;
5500	std::vector<double> _M_cp;
5501	};
5502
5503	discrete_distribution()
5504	: _M_param()
5505	{ }
5506
5507	template<typename _InputIterator>
5508	discrete_distribution(_InputIterator __wbegin,
5509	_InputIterator __wend)
5510	: _M_param(__wbegin, __wend)
5511	{ }
5512
5513	discrete_distribution(initializer_list<double> __wl)
5514	: _M_param(__wl)
5515	{ }
5516
5517	template<typename _Func>
5518	discrete_distribution(size_t __nw, double __xmin, double __xmax,
5519	_Func __fw)
5520	: _M_param(__nw, __xmin, __xmax, __fw)
5521	{ }
5522
5523	explicit
5524	discrete_distribution(const param_type& __p)
5525	: _M_param(__p)
5526	{ }
5527
5528	/**
5529	* @brief Resets the distribution state.
5530	*/
5531	void
5532	reset()
5533	{ }
5534
5535	/**
5536	* @brief Returns the probabilities of the distribution.
5537	*/
5538	std::vector<double>
5539	probabilities() const
5540	{
5541	return _M_param._M_prob.empty()
5542	? std::vector<double>(1, 1.0) : _M_param._M_prob;
5543	}
5544
5545	/**
5546	* @brief Returns the parameter set of the distribution.
5547	*/
5548	param_type
5549	param() const
5550	{ return _M_param; }
5551
5552	/**
5553	* @brief Sets the parameter set of the distribution.
5554	* @param __param The new parameter set of the distribution.
5555	*/
5556	void
5557	param(const param_type& __param)
5558	{ _M_param = __param; }
5559
5560	/**
5561	* @brief Returns the greatest lower bound value of the distribution.
5562	*/
5563	result_type
5564	min() const
5565	{ return result_type(0); }
5566
5567	/**
5568	* @brief Returns the least upper bound value of the distribution.
5569	*/
5570	result_type
5571	max() const
5572	{
5573	return _M_param._M_prob.empty()
5574	? result_type(0) : result_type(_M_param._M_prob.size() - 1);
5575	}
5576
5577	/**
5578	* @brief Generating functions.
5579	*/
5580	template<typename _UniformRandomNumberGenerator>
5581	result_type
5582	operator()(_UniformRandomNumberGenerator& __urng)
5583	{ return this->operator()(__urng, _M_param); }
5584
5585	template<typename _UniformRandomNumberGenerator>
5586	result_type
5587	operator()(_UniformRandomNumberGenerator& __urng,
5588	const param_type& __p);
5589
5590	template<typename _ForwardIterator,
5591	typename _UniformRandomNumberGenerator>
5592	void
5593	__generate(_ForwardIterator __f, _ForwardIterator __t,
5594	_UniformRandomNumberGenerator& __urng)
5595	{ this->__generate(__f, __t, __urng, _M_param); }
5596
5597	template<typename _ForwardIterator,
5598	typename _UniformRandomNumberGenerator>
5599	void
5600	__generate(_ForwardIterator __f, _ForwardIterator __t,
5601	_UniformRandomNumberGenerator& __urng,
5602	const param_type& __p)
5603	{ this->__generate_impl(__f, __t, __urng, __p); }
5604
5605	template<typename _UniformRandomNumberGenerator>
5606	void
5607	__generate(result_type* __f, result_type* __t,
5608	_UniformRandomNumberGenerator& __urng,
5609	const param_type& __p)
5610	{ this->__generate_impl(__f, __t, __urng, __p); }
5611
5612	/**
5613	* @brief Return true if two discrete distributions have the same
5614	* parameters.
5615	*/
5616	friend bool
5617	operator==(const discrete_distribution& __d1,
5618	const discrete_distribution& __d2)
5619	{ return __d1._M_param == __d2._M_param; }
5620
5621	/**
5622	* @brief Inserts a %discrete_distribution random number distribution
5623	* @p __x into the output stream @p __os.
5624	*
5625	* @param __os An output stream.
5626	* @param __x A %discrete_distribution random number distribution.
5627	*
5628	* @returns The output stream with the state of @p __x inserted or in
5629	* an error state.
5630	*/
5631	template<typename _IntType1, typename _CharT, typename _Traits>
5632	friend std::basic_ostream<_CharT, _Traits>&
5633	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5634	const std::discrete_distribution<_IntType1>& __x);
5635
5636	/**
5637	* @brief Extracts a %discrete_distribution random number distribution
5638	* @p __x from the input stream @p __is.
5639	*
5640	* @param __is An input stream.
5641	* @param __x A %discrete_distribution random number
5642	* generator engine.
5643	*
5644	* @returns The input stream with @p __x extracted or in an error
5645	* state.
5646	*/
5647	template<typename _IntType1, typename _CharT, typename _Traits>
5648	friend std::basic_istream<_CharT, _Traits>&
5649	operator>>(std::basic_istream<_CharT, _Traits>& __is,
5650	std::discrete_distribution<_IntType1>& __x);
5651
5652	private:
5653	template<typename _ForwardIterator,
5654	typename _UniformRandomNumberGenerator>
5655	void
5656	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5657	_UniformRandomNumberGenerator& __urng,
5658	const param_type& __p);
5659
5660	param_type _M_param;
5661	};
5662
5663	#if __cpp_impl_three_way_comparison < 201907L
5664	/**
5665	* @brief Return true if two discrete distributions have different
5666	* parameters.
5667	*/
5668	template<typename _IntType>
5669	inline bool
5670	operator!=(const std::discrete_distribution<_IntType>& __d1,
5671	const std::discrete_distribution<_IntType>& __d2)
5672	{ return !(__d1 == __d2); }
5673	#endif
5674
5675	/**
5676	* @brief A piecewise_constant_distribution random number distribution.
5677	*
5678	* This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
5679	* uniformly distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
5680	* according to the probability mass function
5681	* @f[
5682	* p(x | b_0, ..., b_n, \rho_0, ..., \rho_{n-1})
5683	* = \rho_i \cdot \frac{b_{i+1} - x}{b_{i+1} - b_i}
5684	* + \rho_{i+1} \cdot \frac{ x - b_i}{b_{i+1} - b_i}
5685	* @f]
5686	* for @f$ b_i \leq x < b_{i+1} @f$.
5687	*
5688	* @headerfile random
5689	* @since C++11
5690	*/
5691	template<typename _RealType = double>
5692	class piecewise_constant_distribution
5693	{
5694	static_assert(std::is_floating_point<_RealType>::value,
5695	"result_type must be a floating point type");
5696
5697	public:
5698	/** The type of the range of the distribution. */
5699	typedef _RealType result_type;
5700
5701	/** Parameter type. */
5702	struct param_type
5703	{
5704	typedef piecewise_constant_distribution<_RealType> distribution_type;
5705	friend class piecewise_constant_distribution<_RealType>;
5706
5707	param_type()
5708	: _M_int(), _M_den(), _M_cp()
5709	{ }
5710
5711	template<typename _InputIteratorB, typename _InputIteratorW>
5712	param_type(_InputIteratorB __bfirst,
5713	_InputIteratorB __bend,
5714	_InputIteratorW __wbegin);
5715
5716	template<typename _Func>
5717	param_type(initializer_list<_RealType> __bi, _Func __fw);
5718
5719	template<typename _Func>
5720	param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
5721	_Func __fw);
5722
5723	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5724	param_type(const param_type&) = default;
5725	param_type& operator=(const param_type&) = default;
5726
5727	std::vector<_RealType>
5728	intervals() const
5729	{
5730	if (_M_int.empty())
5731	{
5732	std::vector<_RealType> __tmp(2);
5733	__tmp[1] = _RealType(1);
5734	return __tmp;
5735	}
5736	else
5737	return _M_int;
5738	}
5739
5740	std::vector<double>
5741	densities() const
5742	{ return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
5743
5744	friend bool
5745	operator==(const param_type& __p1, const param_type& __p2)
5746	{ return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5747
5748	#if __cpp_impl_three_way_comparison < 201907L
5749	friend bool
5750	operator!=(const param_type& __p1, const param_type& __p2)
5751	{ return !(__p1 == __p2); }
5752	#endif
5753
5754	private:
5755	void
5756	_M_initialize();
5757
5758	std::vector<_RealType> _M_int;
5759	std::vector<double> _M_den;
5760	std::vector<double> _M_cp;
5761	};
5762
5763	piecewise_constant_distribution()
5764	: _M_param()
5765	{ }
5766
5767	template<typename _InputIteratorB, typename _InputIteratorW>
5768	piecewise_constant_distribution(_InputIteratorB __bfirst,
5769	_InputIteratorB __bend,
5770	_InputIteratorW __wbegin)
5771	: _M_param(__bfirst, __bend, __wbegin)
5772	{ }
5773
5774	template<typename _Func>
5775	piecewise_constant_distribution(initializer_list<_RealType> __bl,
5776	_Func __fw)
5777	: _M_param(__bl, __fw)
5778	{ }
5779
5780	template<typename _Func>
5781	piecewise_constant_distribution(size_t __nw,
5782	_RealType __xmin, _RealType __xmax,
5783	_Func __fw)
5784	: _M_param(__nw, __xmin, __xmax, __fw)
5785	{ }
5786
5787	explicit
5788	piecewise_constant_distribution(const param_type& __p)
5789	: _M_param(__p)
5790	{ }
5791
5792	/**
5793	* @brief Resets the distribution state.
5794	*/
5795	void
5796	reset()
5797	{ }
5798
5799	/**
5800	* @brief Returns a vector of the intervals.
5801	*/
5802	std::vector<_RealType>
5803	intervals() const
5804	{
5805	if (_M_param._M_int.empty())
5806	{
5807	std::vector<_RealType> __tmp(2);
5808	__tmp[1] = _RealType(1);
5809	return __tmp;
5810	}
5811	else
5812	return _M_param._M_int;
5813	}
5814
5815	/**
5816	* @brief Returns a vector of the probability densities.
5817	*/
5818	std::vector<double>
5819	densities() const
5820	{
5821	return _M_param._M_den.empty()
5822	? std::vector<double>(1, 1.0) : _M_param._M_den;
5823	}
5824
5825	/**
5826	* @brief Returns the parameter set of the distribution.
5827	*/
5828	param_type
5829	param() const
5830	{ return _M_param; }
5831
5832	/**
5833	* @brief Sets the parameter set of the distribution.
5834	* @param __param The new parameter set of the distribution.
5835	*/
5836	void
5837	param(const param_type& __param)
5838	{ _M_param = __param; }
5839
5840	/**
5841	* @brief Returns the greatest lower bound value of the distribution.
5842	*/
5843	result_type
5844	min() const
5845	{
5846	return _M_param._M_int.empty()
5847	? result_type(0) : _M_param._M_int.front();
5848	}
5849
5850	/**
5851	* @brief Returns the least upper bound value of the distribution.
5852	*/
5853	result_type
5854	max() const
5855	{
5856	return _M_param._M_int.empty()
5857	? result_type(1) : _M_param._M_int.back();
5858	}
5859
5860	/**
5861	* @brief Generating functions.
5862	*/
5863	template<typename _UniformRandomNumberGenerator>
5864	result_type
5865	operator()(_UniformRandomNumberGenerator& __urng)
5866	{ return this->operator()(__urng, _M_param); }
5867
5868	template<typename _UniformRandomNumberGenerator>
5869	result_type
5870	operator()(_UniformRandomNumberGenerator& __urng,
5871	const param_type& __p);
5872
5873	template<typename _ForwardIterator,
5874	typename _UniformRandomNumberGenerator>
5875	void
5876	__generate(_ForwardIterator __f, _ForwardIterator __t,
5877	_UniformRandomNumberGenerator& __urng)
5878	{ this->__generate(__f, __t, __urng, _M_param); }
5879
5880	template<typename _ForwardIterator,
5881	typename _UniformRandomNumberGenerator>
5882	void
5883	__generate(_ForwardIterator __f, _ForwardIterator __t,
5884	_UniformRandomNumberGenerator& __urng,
5885	const param_type& __p)
5886	{ this->__generate_impl(__f, __t, __urng, __p); }
5887
5888	template<typename _UniformRandomNumberGenerator>
5889	void
5890	__generate(result_type* __f, result_type* __t,
5891	_UniformRandomNumberGenerator& __urng,
5892	const param_type& __p)
5893	{ this->__generate_impl(__f, __t, __urng, __p); }
5894
5895	/**
5896	* @brief Return true if two piecewise constant distributions have the
5897	* same parameters.
5898	*/
5899	friend bool
5900	operator==(const piecewise_constant_distribution& __d1,
5901	const piecewise_constant_distribution& __d2)
5902	{ return __d1._M_param == __d2._M_param; }
5903
5904	/**
5905	* @brief Inserts a %piecewise_constant_distribution random
5906	* number distribution @p __x into the output stream @p __os.
5907	*
5908	* @param __os An output stream.
5909	* @param __x A %piecewise_constant_distribution random number
5910	* distribution.
5911	*
5912	* @returns The output stream with the state of @p __x inserted or in
5913	* an error state.
5914	*/
5915	template<typename _RealType1, typename _CharT, typename _Traits>
5916	friend std::basic_ostream<_CharT, _Traits>&
5917	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5918	const std::piecewise_constant_distribution<_RealType1>& __x);
5919
5920	/**
5921	* @brief Extracts a %piecewise_constant_distribution random
5922	* number distribution @p __x from the input stream @p __is.
5923	*
5924	* @param __is An input stream.
5925	* @param __x A %piecewise_constant_distribution random number
5926	* generator engine.
5927	*
5928	* @returns The input stream with @p __x extracted or in an error
5929	* state.
5930	*/
5931	template<typename _RealType1, typename _CharT, typename _Traits>
5932	friend std::basic_istream<_CharT, _Traits>&
5933	operator>>(std::basic_istream<_CharT, _Traits>& __is,
5934	std::piecewise_constant_distribution<_RealType1>& __x);
5935
5936	private:
5937	template<typename _ForwardIterator,
5938	typename _UniformRandomNumberGenerator>
5939	void
5940	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5941	_UniformRandomNumberGenerator& __urng,
5942	const param_type& __p);
5943
5944	param_type _M_param;
5945	};
5946
5947	#if __cpp_impl_three_way_comparison < 201907L
5948	/**
5949	* @brief Return true if two piecewise constant distributions have
5950	* different parameters.
5951	*/
5952	template<typename _RealType>
5953	inline bool
5954	operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
5955	const std::piecewise_constant_distribution<_RealType>& __d2)
5956	{ return !(__d1 == __d2); }
5957	#endif
5958
5959	/**
5960	* @brief A piecewise_linear_distribution random number distribution.
5961	*
5962	* This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
5963	* distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
5964	* according to the probability mass function
5965	* @f$ p(x | b_0, ..., b_n, \rho_0, ..., \rho_n) = \rho_i @f$,
5966	* for @f$ b_i \leq x < b_{i+1} @f$.
5967	*
5968	* @headerfile random
5969	* @since C++11
5970	*/
5971	template<typename _RealType = double>
5972	class piecewise_linear_distribution
5973	{
5974	static_assert(std::is_floating_point<_RealType>::value,
5975	"result_type must be a floating point type");
5976
5977	public:
5978	/** The type of the range of the distribution. */
5979	typedef _RealType result_type;
5980
5981	/** Parameter type. */
5982	struct param_type
5983	{
5984	typedef piecewise_linear_distribution<_RealType> distribution_type;
5985	friend class piecewise_linear_distribution<_RealType>;
5986
5987	param_type()
5988	: _M_int(), _M_den(), _M_cp(), _M_m()
5989	{ }
5990
5991	template<typename _InputIteratorB, typename _InputIteratorW>
5992	param_type(_InputIteratorB __bfirst,
5993	_InputIteratorB __bend,
5994	_InputIteratorW __wbegin);
5995
5996	template<typename _Func>
5997	param_type(initializer_list<_RealType> __bl, _Func __fw);
5998
5999	template<typename _Func>
6000	param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
6001	_Func __fw);
6002
6003	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
6004	param_type(const param_type&) = default;
6005	param_type& operator=(const param_type&) = default;
6006
6007	std::vector<_RealType>
6008	intervals() const
6009	{
6010	if (_M_int.empty())
6011	{
6012	std::vector<_RealType> __tmp(2);
6013	__tmp[1] = _RealType(1);
6014	return __tmp;
6015	}
6016	else
6017	return _M_int;
6018	}
6019
6020	std::vector<double>
6021	densities() const
6022	{ return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
6023
6024	friend bool
6025	operator==(const param_type& __p1, const param_type& __p2)
6026	{ return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
6027
6028	#if __cpp_impl_three_way_comparison < 201907L
6029	friend bool
6030	operator!=(const param_type& __p1, const param_type& __p2)
6031	{ return !(__p1 == __p2); }
6032	#endif
6033
6034	private:
6035	void
6036	_M_initialize();
6037
6038	std::vector<_RealType> _M_int;
6039	std::vector<double> _M_den;
6040	std::vector<double> _M_cp;
6041	std::vector<double> _M_m;
6042	};
6043
6044	piecewise_linear_distribution()
6045	: _M_param()
6046	{ }
6047
6048	template<typename _InputIteratorB, typename _InputIteratorW>
6049	piecewise_linear_distribution(_InputIteratorB __bfirst,
6050	_InputIteratorB __bend,
6051	_InputIteratorW __wbegin)
6052	: _M_param(__bfirst, __bend, __wbegin)
6053	{ }
6054
6055	template<typename _Func>
6056	piecewise_linear_distribution(initializer_list<_RealType> __bl,
6057	_Func __fw)
6058	: _M_param(__bl, __fw)
6059	{ }
6060
6061	template<typename _Func>
6062	piecewise_linear_distribution(size_t __nw,
6063	_RealType __xmin, _RealType __xmax,
6064	_Func __fw)
6065	: _M_param(__nw, __xmin, __xmax, __fw)
6066	{ }
6067
6068	explicit
6069	piecewise_linear_distribution(const param_type& __p)
6070	: _M_param(__p)
6071	{ }
6072
6073	/**
6074	* Resets the distribution state.
6075	*/
6076	void
6077	reset()
6078	{ }
6079
6080	/**
6081	* @brief Return the intervals of the distribution.
6082	*/
6083	std::vector<_RealType>
6084	intervals() const
6085	{
6086	if (_M_param._M_int.empty())
6087	{
6088	std::vector<_RealType> __tmp(2);
6089	__tmp[1] = _RealType(1);
6090	return __tmp;
6091	}
6092	else
6093	return _M_param._M_int;
6094	}
6095
6096	/**
6097	* @brief Return a vector of the probability densities of the
6098	* distribution.
6099	*/
6100	std::vector<double>
6101	densities() const
6102	{
6103	return _M_param._M_den.empty()
6104	? std::vector<double>(2, 1.0) : _M_param._M_den;
6105	}
6106
6107	/**
6108	* @brief Returns the parameter set of the distribution.
6109	*/
6110	param_type
6111	param() const
6112	{ return _M_param; }
6113
6114	/**
6115	* @brief Sets the parameter set of the distribution.
6116	* @param __param The new parameter set of the distribution.
6117	*/
6118	void
6119	param(const param_type& __param)
6120	{ _M_param = __param; }
6121
6122	/**
6123	* @brief Returns the greatest lower bound value of the distribution.
6124	*/
6125	result_type
6126	min() const
6127	{
6128	return _M_param._M_int.empty()
6129	? result_type(0) : _M_param._M_int.front();
6130	}
6131
6132	/**
6133	* @brief Returns the least upper bound value of the distribution.
6134	*/
6135	result_type
6136	max() const
6137	{
6138	return _M_param._M_int.empty()
6139	? result_type(1) : _M_param._M_int.back();
6140	}
6141
6142	/**
6143	* @brief Generating functions.
6144	*/
6145	template<typename _UniformRandomNumberGenerator>
6146	result_type
6147	operator()(_UniformRandomNumberGenerator& __urng)
6148	{ return this->operator()(__urng, _M_param); }
6149
6150	template<typename _UniformRandomNumberGenerator>
6151	result_type
6152	operator()(_UniformRandomNumberGenerator& __urng,
6153	const param_type& __p);
6154
6155	template<typename _ForwardIterator,
6156	typename _UniformRandomNumberGenerator>
6157	void
6158	__generate(_ForwardIterator __f, _ForwardIterator __t,
6159	_UniformRandomNumberGenerator& __urng)
6160	{ this->__generate(__f, __t, __urng, _M_param); }
6161
6162	template<typename _ForwardIterator,
6163	typename _UniformRandomNumberGenerator>
6164	void
6165	__generate(_ForwardIterator __f, _ForwardIterator __t,
6166	_UniformRandomNumberGenerator& __urng,
6167	const param_type& __p)
6168	{ this->__generate_impl(__f, __t, __urng, __p); }
6169
6170	template<typename _UniformRandomNumberGenerator>
6171	void
6172	__generate(result_type* __f, result_type* __t,
6173	_UniformRandomNumberGenerator& __urng,
6174	const param_type& __p)
6175	{ this->__generate_impl(__f, __t, __urng, __p); }
6176
6177	/**
6178	* @brief Return true if two piecewise linear distributions have the
6179	* same parameters.
6180	*/
6181	friend bool
6182	operator==(const piecewise_linear_distribution& __d1,
6183	const piecewise_linear_distribution& __d2)
6184	{ return __d1._M_param == __d2._M_param; }
6185
6186	/**
6187	* @brief Inserts a %piecewise_linear_distribution random number
6188	* distribution @p __x into the output stream @p __os.
6189	*
6190	* @param __os An output stream.
6191	* @param __x A %piecewise_linear_distribution random number
6192	* distribution.
6193	*
6194	* @returns The output stream with the state of @p __x inserted or in
6195	* an error state.
6196	*/
6197	template<typename _RealType1, typename _CharT, typename _Traits>
6198	friend std::basic_ostream<_CharT, _Traits>&
6199	operator<<(std::basic_ostream<_CharT, _Traits>& __os,
6200	const std::piecewise_linear_distribution<_RealType1>& __x);
6201
6202	/**
6203	* @brief Extracts a %piecewise_linear_distribution random number
6204	* distribution @p __x from the input stream @p __is.
6205	*
6206	* @param __is An input stream.
6207	* @param __x A %piecewise_linear_distribution random number
6208	* generator engine.
6209	*
6210	* @returns The input stream with @p __x extracted or in an error
6211	* state.
6212	*/
6213	template<typename _RealType1, typename _CharT, typename _Traits>
6214	friend std::basic_istream<_CharT, _Traits>&
6215	operator>>(std::basic_istream<_CharT, _Traits>& __is,
6216	std::piecewise_linear_distribution<_RealType1>& __x);
6217
6218	private:
6219	template<typename _ForwardIterator,
6220	typename _UniformRandomNumberGenerator>
6221	void
6222	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6223	_UniformRandomNumberGenerator& __urng,
6224	const param_type& __p);
6225
6226	param_type _M_param;
6227	};
6228
6229	#if __cpp_impl_three_way_comparison < 201907L
6230	/**
6231	* @brief Return true if two piecewise linear distributions have
6232	* different parameters.
6233	*/
6234	template<typename _RealType>
6235	inline bool
6236	operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
6237	const std::piecewise_linear_distribution<_RealType>& __d2)
6238	{ return !(__d1 == __d2); }
6239	#endif
6240
6241	/// @} group random_distributions_sampling
6242
6243	/// @} *group random_distributions
6244
6245	/**
6246	* @addtogroup random_utilities Random Number Utilities
6247	* @ingroup random
6248	* @{
6249	*/
6250
6251	/**
6252	* @brief The seed_seq class generates sequences of seeds for random
6253	* number generators.
6254	*
6255	* @headerfile random
6256	* @since C++11
6257	*/
6258	class seed_seq
6259	{
6260	public:
6261	/** The type of the seed vales. */
6262	typedef uint_least32_t result_type;
6263
6264	/** Default constructor. */
6265	seed_seq() noexcept
6266	: _M_v()
6267	{ }
6268
6269	template<typename _IntType, typename = _Require<is_integral<_IntType>>>
6270	seed_seq(std::initializer_list<_IntType> __il);
6271
6272	template<typename _InputIterator>
6273	seed_seq(_InputIterator __begin, _InputIterator __end);
6274
6275	// generating functions
6276	template<typename _RandomAccessIterator>
6277	void
6278	generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6279
6280	// property functions
6281	size_t size() const noexcept
6282	{ return _M_v.size(); }
6283
6284	template<typename _OutputIterator>
6285	void
6286	param(_OutputIterator __dest) const
6287	{ std::copy(_M_v.begin(), _M_v.end(), __dest); }
6288
6289	// no copy functions
6290	seed_seq(const seed_seq&) = delete;
6291	seed_seq& operator=(const seed_seq&) = delete;
6292
6293	private:
6294	std::vector<result_type> _M_v;
6295	};
6296
6297	/// @} group random_utilities
6298
6299	/// @} group random
6300
6301	_GLIBCXX_END_NAMESPACE_VERSION
6302	} // namespace std
6303
6304	#endif
6305