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

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

Source File include/c++/11/bits/random.hHome Page Browse Root

Source File include/c++/11/bits/random.h
Home Page Browse Root