random.h source code [include/c++/7/bits/random.h]

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