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

my random.h archive