2 //===--------------------------- random -----------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_RANDOM
12 #define _LIBCPP_RANDOM
17 #include <initializer_list>
24 template <class UIntType, UIntType a, UIntType c, UIntType m>
25 class linear_congruential_engine
29 typedef UIntType result_type;
31 // engine characteristics
32 static constexpr result_type multiplier = a;
33 static constexpr result_type increment = c;
34 static constexpr result_type modulus = m;
35 static constexpr result_type min() { return c == 0u ? 1u: 0u;}
36 static constexpr result_type max() { return m - 1u;}
37 static constexpr result_type default_seed = 1u;
39 // constructors and seeding functions
40 explicit linear_congruential_engine(result_type s = default_seed);
41 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
42 void seed(result_type s = default_seed);
43 template<class Sseq> void seed(Sseq& q);
45 // generating functions
46 result_type operator()();
47 void discard(unsigned long long z);
50 template <class UIntType, UIntType a, UIntType c, UIntType m>
52 operator==(const linear_congruential_engine<UIntType, a, c, m>& x,
53 const linear_congruential_engine<UIntType, a, c, m>& y);
55 template <class UIntType, UIntType a, UIntType c, UIntType m>
57 operator!=(const linear_congruential_engine<UIntType, a, c, m>& x,
58 const linear_congruential_engine<UIntType, a, c, m>& y);
60 template <class charT, class traits,
61 class UIntType, UIntType a, UIntType c, UIntType m>
62 basic_ostream<charT, traits>&
63 operator<<(basic_ostream<charT, traits>& os,
64 const linear_congruential_engine<UIntType, a, c, m>& x);
66 template <class charT, class traits,
67 class UIntType, UIntType a, UIntType c, UIntType m>
68 basic_istream<charT, traits>&
69 operator>>(basic_istream<charT, traits>& is,
70 linear_congruential_engine<UIntType, a, c, m>& x);
72 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
73 UIntType a, size_t u, UIntType d, size_t s,
74 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
75 class mersenne_twister_engine
79 typedef UIntType result_type;
81 // engine characteristics
82 static constexpr size_t word_size = w;
83 static constexpr size_t state_size = n;
84 static constexpr size_t shift_size = m;
85 static constexpr size_t mask_bits = r;
86 static constexpr result_type xor_mask = a;
87 static constexpr size_t tempering_u = u;
88 static constexpr result_type tempering_d = d;
89 static constexpr size_t tempering_s = s;
90 static constexpr result_type tempering_b = b;
91 static constexpr size_t tempering_t = t;
92 static constexpr result_type tempering_c = c;
93 static constexpr size_t tempering_l = l;
94 static constexpr result_type initialization_multiplier = f;
95 static constexpr result_type min () { return 0; }
96 static constexpr result_type max() { return 2^w - 1; }
97 static constexpr result_type default_seed = 5489u;
99 // constructors and seeding functions
100 explicit mersenne_twister_engine(result_type value = default_seed);
101 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
102 void seed(result_type value = default_seed);
103 template<class Sseq> void seed(Sseq& q);
105 // generating functions
106 result_type operator()();
107 void discard(unsigned long long z);
110 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
111 UIntType a, size_t u, UIntType d, size_t s,
112 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
115 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
116 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
118 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
119 UIntType a, size_t u, UIntType d, size_t s,
120 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
123 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
124 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
126 template <class charT, class traits,
127 class UIntType, size_t w, size_t n, size_t m, size_t r,
128 UIntType a, size_t u, UIntType d, size_t s,
129 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
130 basic_ostream<charT, traits>&
131 operator<<(basic_ostream<charT, traits>& os,
132 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
134 template <class charT, class traits,
135 class UIntType, size_t w, size_t n, size_t m, size_t r,
136 UIntType a, size_t u, UIntType d, size_t s,
137 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
138 basic_istream<charT, traits>&
139 operator>>(basic_istream<charT, traits>& is,
140 mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
142 template<class UIntType, size_t w, size_t s, size_t r>
143 class subtract_with_carry_engine
147 typedef UIntType result_type;
149 // engine characteristics
150 static constexpr size_t word_size = w;
151 static constexpr size_t short_lag = s;
152 static constexpr size_t long_lag = r;
153 static constexpr result_type min() { return 0; }
154 static constexpr result_type max() { return m-1; }
155 static constexpr result_type default_seed = 19780503u;
157 // constructors and seeding functions
158 explicit subtract_with_carry_engine(result_type value = default_seed);
159 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
160 void seed(result_type value = default_seed);
161 template<class Sseq> void seed(Sseq& q);
163 // generating functions
164 result_type operator()();
165 void discard(unsigned long long z);
168 template<class UIntType, size_t w, size_t s, size_t r>
171 const subtract_with_carry_engine<UIntType, w, s, r>& x,
172 const subtract_with_carry_engine<UIntType, w, s, r>& y);
174 template<class UIntType, size_t w, size_t s, size_t r>
177 const subtract_with_carry_engine<UIntType, w, s, r>& x,
178 const subtract_with_carry_engine<UIntType, w, s, r>& y);
180 template <class charT, class traits,
181 class UIntType, size_t w, size_t s, size_t r>
182 basic_ostream<charT, traits>&
183 operator<<(basic_ostream<charT, traits>& os,
184 const subtract_with_carry_engine<UIntType, w, s, r>& x);
186 template <class charT, class traits,
187 class UIntType, size_t w, size_t s, size_t r>
188 basic_istream<charT, traits>&
189 operator>>(basic_istream<charT, traits>& is,
190 subtract_with_carry_engine<UIntType, w, s, r>& x);
192 template<class Engine, size_t p, size_t r>
193 class discard_block_engine
197 typedef typename Engine::result_type result_type;
199 // engine characteristics
200 static constexpr size_t block_size = p;
201 static constexpr size_t used_block = r;
202 static constexpr result_type min() { return Engine::min(); }
203 static constexpr result_type max() { return Engine::max(); }
205 // constructors and seeding functions
206 discard_block_engine();
207 explicit discard_block_engine(const Engine& e);
208 explicit discard_block_engine(Engine&& e);
209 explicit discard_block_engine(result_type s);
210 template<class Sseq> explicit discard_block_engine(Sseq& q);
212 void seed(result_type s);
213 template<class Sseq> void seed(Sseq& q);
215 // generating functions
216 result_type operator()();
217 void discard(unsigned long long z);
219 // property functions
220 const Engine& base() const noexcept;
223 template<class Engine, size_t p, size_t r>
226 const discard_block_engine<Engine, p, r>& x,
227 const discard_block_engine<Engine, p, r>& y);
229 template<class Engine, size_t p, size_t r>
232 const discard_block_engine<Engine, p, r>& x,
233 const discard_block_engine<Engine, p, r>& y);
235 template <class charT, class traits,
236 class Engine, size_t p, size_t r>
237 basic_ostream<charT, traits>&
238 operator<<(basic_ostream<charT, traits>& os,
239 const discard_block_engine<Engine, p, r>& x);
241 template <class charT, class traits,
242 class Engine, size_t p, size_t r>
243 basic_istream<charT, traits>&
244 operator>>(basic_istream<charT, traits>& is,
245 discard_block_engine<Engine, p, r>& x);
247 template<class Engine, size_t w, class UIntType>
248 class independent_bits_engine
252 typedef UIntType result_type;
254 // engine characteristics
255 static constexpr result_type min() { return 0; }
256 static constexpr result_type max() { return 2^w - 1; }
258 // constructors and seeding functions
259 independent_bits_engine();
260 explicit independent_bits_engine(const Engine& e);
261 explicit independent_bits_engine(Engine&& e);
262 explicit independent_bits_engine(result_type s);
263 template<class Sseq> explicit independent_bits_engine(Sseq& q);
265 void seed(result_type s);
266 template<class Sseq> void seed(Sseq& q);
268 // generating functions
269 result_type operator()(); void discard(unsigned long long z);
271 // property functions
272 const Engine& base() const noexcept;
275 template<class Engine, size_t w, class UIntType>
278 const independent_bits_engine<Engine, w, UIntType>& x,
279 const independent_bits_engine<Engine, w, UIntType>& y);
281 template<class Engine, size_t w, class UIntType>
284 const independent_bits_engine<Engine, w, UIntType>& x,
285 const independent_bits_engine<Engine, w, UIntType>& y);
287 template <class charT, class traits,
288 class Engine, size_t w, class UIntType>
289 basic_ostream<charT, traits>&
290 operator<<(basic_ostream<charT, traits>& os,
291 const independent_bits_engine<Engine, w, UIntType>& x);
293 template <class charT, class traits,
294 class Engine, size_t w, class UIntType>
295 basic_istream<charT, traits>&
296 operator>>(basic_istream<charT, traits>& is,
297 independent_bits_engine<Engine, w, UIntType>& x);
299 template<class Engine, size_t k>
300 class shuffle_order_engine
304 typedef typename Engine::result_type result_type;
306 // engine characteristics
307 static constexpr size_t table_size = k;
308 static constexpr result_type min() { return Engine::min; }
309 static constexpr result_type max() { return Engine::max; }
311 // constructors and seeding functions
312 shuffle_order_engine();
313 explicit shuffle_order_engine(const Engine& e);
314 explicit shuffle_order_engine(Engine&& e);
315 explicit shuffle_order_engine(result_type s);
316 template<class Sseq> explicit shuffle_order_engine(Sseq& q);
318 void seed(result_type s);
319 template<class Sseq> void seed(Sseq& q);
321 // generating functions
322 result_type operator()();
323 void discard(unsigned long long z);
325 // property functions
326 const Engine& base() const noexcept;
329 template<class Engine, size_t k>
332 const shuffle_order_engine<Engine, k>& x,
333 const shuffle_order_engine<Engine, k>& y);
335 template<class Engine, size_t k>
338 const shuffle_order_engine<Engine, k>& x,
339 const shuffle_order_engine<Engine, k>& y);
341 template <class charT, class traits,
342 class Engine, size_t k>
343 basic_ostream<charT, traits>&
344 operator<<(basic_ostream<charT, traits>& os,
345 const shuffle_order_engine<Engine, k>& x);
347 template <class charT, class traits,
348 class Engine, size_t k>
349 basic_istream<charT, traits>&
350 operator>>(basic_istream<charT, traits>& is,
351 shuffle_order_engine<Engine, k>& x);
353 typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
355 typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
357 typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
362 18, 1812433253> mt19937;
363 typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
365 29, 0x5555555555555555,
366 17, 0x71d67fffeda60000,
367 37, 0xfff7eee000000000,
368 43, 6364136223846793005> mt19937_64;
369 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
370 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
371 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
372 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
373 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
374 typedef minstd_rand default_random_engine;
382 typedef unsigned int result_type;
384 // generator characteristics
385 static constexpr result_type min() { return numeric_limits<result_type>::min(); }
386 static constexpr result_type max() { return numeric_limits<result_type>::max(); }
389 explicit random_device(const string& token = "/dev/urandom");
391 // generating functions
392 result_type operator()();
394 // property functions
395 double entropy() const noexcept;
398 random_device(const random_device& ) = delete;
399 void operator=(const random_device& ) = delete;
408 typedef uint_least32_t result_type;
413 seed_seq(initializer_list<T> il);
414 template<class InputIterator>
415 seed_seq(InputIterator begin, InputIterator end);
417 // generating functions
418 template<class RandomAccessIterator>
419 void generate(RandomAccessIterator begin, RandomAccessIterator end);
421 // property functions
423 template<class OutputIterator>
424 void param(OutputIterator dest) const;
427 seed_seq(const seed_seq&) = delete;
428 void operator=(const seed_seq& ) = delete;
431 template<class RealType, size_t bits, class URNG>
432 RealType generate_canonical(URNG& g);
436 template<class IntType = int>
437 class uniform_int_distribution
441 typedef IntType result_type;
446 typedef uniform_int_distribution distribution_type;
448 explicit param_type(IntType a = 0,
449 IntType b = numeric_limits<IntType>::max());
451 result_type a() const;
452 result_type b() const;
454 friend bool operator==(const param_type& x, const param_type& y);
455 friend bool operator!=(const param_type& x, const param_type& y);
458 // constructors and reset functions
459 explicit uniform_int_distribution(IntType a = 0,
460 IntType b = numeric_limits<IntType>::max());
461 explicit uniform_int_distribution(const param_type& parm);
464 // generating functions
465 template<class URNG> result_type operator()(URNG& g);
466 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
468 // property functions
469 result_type a() const;
470 result_type b() const;
472 param_type param() const;
473 void param(const param_type& parm);
475 result_type min() const;
476 result_type max() const;
478 friend bool operator==(const uniform_int_distribution& x,
479 const uniform_int_distribution& y);
480 friend bool operator!=(const uniform_int_distribution& x,
481 const uniform_int_distribution& y);
483 template <class charT, class traits>
485 basic_ostream<charT, traits>&
486 operator<<(basic_ostream<charT, traits>& os,
487 const uniform_int_distribution& x);
489 template <class charT, class traits>
491 basic_istream<charT, traits>&
492 operator>>(basic_istream<charT, traits>& is,
493 uniform_int_distribution& x);
496 template<class RealType = double>
497 class uniform_real_distribution
501 typedef RealType result_type;
506 typedef uniform_real_distribution distribution_type;
508 explicit param_type(RealType a = 0,
511 result_type a() const;
512 result_type b() const;
514 friend bool operator==(const param_type& x, const param_type& y);
515 friend bool operator!=(const param_type& x, const param_type& y);
518 // constructors and reset functions
519 explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
520 explicit uniform_real_distribution(const param_type& parm);
523 // generating functions
524 template<class URNG> result_type operator()(URNG& g);
525 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
527 // property functions
528 result_type a() const;
529 result_type b() const;
531 param_type param() const;
532 void param(const param_type& parm);
534 result_type min() const;
535 result_type max() const;
537 friend bool operator==(const uniform_real_distribution& x,
538 const uniform_real_distribution& y);
539 friend bool operator!=(const uniform_real_distribution& x,
540 const uniform_real_distribution& y);
542 template <class charT, class traits>
544 basic_ostream<charT, traits>&
545 operator<<(basic_ostream<charT, traits>& os,
546 const uniform_real_distribution& x);
548 template <class charT, class traits>
550 basic_istream<charT, traits>&
551 operator>>(basic_istream<charT, traits>& is,
552 uniform_real_distribution& x);
555 class bernoulli_distribution
559 typedef bool result_type;
564 typedef bernoulli_distribution distribution_type;
566 explicit param_type(double p = 0.5);
570 friend bool operator==(const param_type& x, const param_type& y);
571 friend bool operator!=(const param_type& x, const param_type& y);
574 // constructors and reset functions
575 explicit bernoulli_distribution(double p = 0.5);
576 explicit bernoulli_distribution(const param_type& parm);
579 // generating functions
580 template<class URNG> result_type operator()(URNG& g);
581 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
583 // property functions
586 param_type param() const;
587 void param(const param_type& parm);
589 result_type min() const;
590 result_type max() const;
592 friend bool operator==(const bernoulli_distribution& x,
593 const bernoulli_distribution& y);
594 friend bool operator!=(const bernoulli_distribution& x,
595 const bernoulli_distribution& y);
597 template <class charT, class traits>
599 basic_ostream<charT, traits>&
600 operator<<(basic_ostream<charT, traits>& os,
601 const bernoulli_distribution& x);
603 template <class charT, class traits>
605 basic_istream<charT, traits>&
606 operator>>(basic_istream<charT, traits>& is,
607 bernoulli_distribution& x);
610 template<class IntType = int>
611 class binomial_distribution
615 typedef IntType result_type;
620 typedef binomial_distribution distribution_type;
622 explicit param_type(IntType t = 1, double p = 0.5);
627 friend bool operator==(const param_type& x, const param_type& y);
628 friend bool operator!=(const param_type& x, const param_type& y);
631 // constructors and reset functions
632 explicit binomial_distribution(IntType t = 1, double p = 0.5);
633 explicit binomial_distribution(const param_type& parm);
636 // generating functions
637 template<class URNG> result_type operator()(URNG& g);
638 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
640 // property functions
644 param_type param() const;
645 void param(const param_type& parm);
647 result_type min() const;
648 result_type max() const;
650 friend bool operator==(const binomial_distribution& x,
651 const binomial_distribution& y);
652 friend bool operator!=(const binomial_distribution& x,
653 const binomial_distribution& y);
655 template <class charT, class traits>
657 basic_ostream<charT, traits>&
658 operator<<(basic_ostream<charT, traits>& os,
659 const binomial_distribution& x);
661 template <class charT, class traits>
663 basic_istream<charT, traits>&
664 operator>>(basic_istream<charT, traits>& is,
665 binomial_distribution& x);
668 template<class IntType = int>
669 class geometric_distribution
673 typedef IntType result_type;
678 typedef geometric_distribution distribution_type;
680 explicit param_type(double p = 0.5);
684 friend bool operator==(const param_type& x, const param_type& y);
685 friend bool operator!=(const param_type& x, const param_type& y);
688 // constructors and reset functions
689 explicit geometric_distribution(double p = 0.5);
690 explicit geometric_distribution(const param_type& parm);
693 // generating functions
694 template<class URNG> result_type operator()(URNG& g);
695 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
697 // property functions
700 param_type param() const;
701 void param(const param_type& parm);
703 result_type min() const;
704 result_type max() const;
706 friend bool operator==(const geometric_distribution& x,
707 const geometric_distribution& y);
708 friend bool operator!=(const geometric_distribution& x,
709 const geometric_distribution& y);
711 template <class charT, class traits>
713 basic_ostream<charT, traits>&
714 operator<<(basic_ostream<charT, traits>& os,
715 const geometric_distribution& x);
717 template <class charT, class traits>
719 basic_istream<charT, traits>&
720 operator>>(basic_istream<charT, traits>& is,
721 geometric_distribution& x);
724 template<class IntType = int>
725 class negative_binomial_distribution
729 typedef IntType result_type;
734 typedef negative_binomial_distribution distribution_type;
736 explicit param_type(result_type k = 1, double p = 0.5);
738 result_type k() const;
741 friend bool operator==(const param_type& x, const param_type& y);
742 friend bool operator!=(const param_type& x, const param_type& y);
745 // constructor and reset functions
746 explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
747 explicit negative_binomial_distribution(const param_type& parm);
750 // generating functions
751 template<class URNG> result_type operator()(URNG& g);
752 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
754 // property functions
755 result_type k() const;
758 param_type param() const;
759 void param(const param_type& parm);
761 result_type min() const;
762 result_type max() const;
764 friend bool operator==(const negative_binomial_distribution& x,
765 const negative_binomial_distribution& y);
766 friend bool operator!=(const negative_binomial_distribution& x,
767 const negative_binomial_distribution& y);
769 template <class charT, class traits>
771 basic_ostream<charT, traits>&
772 operator<<(basic_ostream<charT, traits>& os,
773 const negative_binomial_distribution& x);
775 template <class charT, class traits>
777 basic_istream<charT, traits>&
778 operator>>(basic_istream<charT, traits>& is,
779 negative_binomial_distribution& x);
782 template<class IntType = int>
783 class poisson_distribution
787 typedef IntType result_type;
792 typedef poisson_distribution distribution_type;
794 explicit param_type(double mean = 1.0);
798 friend bool operator==(const param_type& x, const param_type& y);
799 friend bool operator!=(const param_type& x, const param_type& y);
802 // constructors and reset functions
803 explicit poisson_distribution(double mean = 1.0);
804 explicit poisson_distribution(const param_type& parm);
807 // generating functions
808 template<class URNG> result_type operator()(URNG& g);
809 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
811 // property functions
814 param_type param() const;
815 void param(const param_type& parm);
817 result_type min() const;
818 result_type max() const;
820 friend bool operator==(const poisson_distribution& x,
821 const poisson_distribution& y);
822 friend bool operator!=(const poisson_distribution& x,
823 const poisson_distribution& y);
825 template <class charT, class traits>
827 basic_ostream<charT, traits>&
828 operator<<(basic_ostream<charT, traits>& os,
829 const poisson_distribution& x);
831 template <class charT, class traits>
833 basic_istream<charT, traits>&
834 operator>>(basic_istream<charT, traits>& is,
835 poisson_distribution& x);
838 template<class RealType = double>
839 class exponential_distribution
843 typedef RealType result_type;
848 typedef exponential_distribution distribution_type;
850 explicit param_type(result_type lambda = 1.0);
852 result_type lambda() const;
854 friend bool operator==(const param_type& x, const param_type& y);
855 friend bool operator!=(const param_type& x, const param_type& y);
858 // constructors and reset functions
859 explicit exponential_distribution(result_type lambda = 1.0);
860 explicit exponential_distribution(const param_type& parm);
863 // generating functions
864 template<class URNG> result_type operator()(URNG& g);
865 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
867 // property functions
868 result_type lambda() const;
870 param_type param() const;
871 void param(const param_type& parm);
873 result_type min() const;
874 result_type max() const;
876 friend bool operator==(const exponential_distribution& x,
877 const exponential_distribution& y);
878 friend bool operator!=(const exponential_distribution& x,
879 const exponential_distribution& y);
881 template <class charT, class traits>
883 basic_ostream<charT, traits>&
884 operator<<(basic_ostream<charT, traits>& os,
885 const exponential_distribution& x);
887 template <class charT, class traits>
889 basic_istream<charT, traits>&
890 operator>>(basic_istream<charT, traits>& is,
891 exponential_distribution& x);
894 template<class RealType = double>
895 class gamma_distribution
899 typedef RealType result_type;
904 typedef gamma_distribution distribution_type;
906 explicit param_type(result_type alpha = 1, result_type beta = 1);
908 result_type alpha() const;
909 result_type beta() const;
911 friend bool operator==(const param_type& x, const param_type& y);
912 friend bool operator!=(const param_type& x, const param_type& y);
915 // constructors and reset functions
916 explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
917 explicit gamma_distribution(const param_type& parm);
920 // generating functions
921 template<class URNG> result_type operator()(URNG& g);
922 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
924 // property functions
925 result_type alpha() const;
926 result_type beta() const;
928 param_type param() const;
929 void param(const param_type& parm);
931 result_type min() const;
932 result_type max() const;
934 friend bool operator==(const gamma_distribution& x,
935 const gamma_distribution& y);
936 friend bool operator!=(const gamma_distribution& x,
937 const gamma_distribution& y);
939 template <class charT, class traits>
941 basic_ostream<charT, traits>&
942 operator<<(basic_ostream<charT, traits>& os,
943 const gamma_distribution& x);
945 template <class charT, class traits>
947 basic_istream<charT, traits>&
948 operator>>(basic_istream<charT, traits>& is,
949 gamma_distribution& x);
952 template<class RealType = double>
953 class weibull_distribution
957 typedef RealType result_type;
962 typedef weibull_distribution distribution_type;
964 explicit param_type(result_type alpha = 1, result_type beta = 1);
966 result_type a() const;
967 result_type b() const;
969 friend bool operator==(const param_type& x, const param_type& y);
970 friend bool operator!=(const param_type& x, const param_type& y);
973 // constructor and reset functions
974 explicit weibull_distribution(result_type a = 1, result_type b = 1);
975 explicit weibull_distribution(const param_type& parm);
978 // generating functions
979 template<class URNG> result_type operator()(URNG& g);
980 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
982 // property functions
983 result_type a() const;
984 result_type b() const;
986 param_type param() const;
987 void param(const param_type& parm);
989 result_type min() const;
990 result_type max() const;
992 friend bool operator==(const weibull_distribution& x,
993 const weibull_distribution& y);
994 friend bool operator!=(const weibull_distribution& x,
995 const weibull_distribution& y);
997 template <class charT, class traits>
999 basic_ostream<charT, traits>&
1000 operator<<(basic_ostream<charT, traits>& os,
1001 const weibull_distribution& x);
1003 template <class charT, class traits>
1005 basic_istream<charT, traits>&
1006 operator>>(basic_istream<charT, traits>& is,
1007 weibull_distribution& x);
1010 template<class RealType = double>
1011 class extreme_value_distribution
1015 typedef RealType result_type;
1020 typedef extreme_value_distribution distribution_type;
1022 explicit param_type(result_type a = 0, result_type b = 1);
1024 result_type a() const;
1025 result_type b() const;
1027 friend bool operator==(const param_type& x, const param_type& y);
1028 friend bool operator!=(const param_type& x, const param_type& y);
1031 // constructor and reset functions
1032 explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
1033 explicit extreme_value_distribution(const param_type& parm);
1036 // generating functions
1037 template<class URNG> result_type operator()(URNG& g);
1038 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1040 // property functions
1041 result_type a() const;
1042 result_type b() const;
1044 param_type param() const;
1045 void param(const param_type& parm);
1047 result_type min() const;
1048 result_type max() const;
1050 friend bool operator==(const extreme_value_distribution& x,
1051 const extreme_value_distribution& y);
1052 friend bool operator!=(const extreme_value_distribution& x,
1053 const extreme_value_distribution& y);
1055 template <class charT, class traits>
1057 basic_ostream<charT, traits>&
1058 operator<<(basic_ostream<charT, traits>& os,
1059 const extreme_value_distribution& x);
1061 template <class charT, class traits>
1063 basic_istream<charT, traits>&
1064 operator>>(basic_istream<charT, traits>& is,
1065 extreme_value_distribution& x);
1068 template<class RealType = double>
1069 class normal_distribution
1073 typedef RealType result_type;
1078 typedef normal_distribution distribution_type;
1080 explicit param_type(result_type mean = 0, result_type stddev = 1);
1082 result_type mean() const;
1083 result_type stddev() const;
1085 friend bool operator==(const param_type& x, const param_type& y);
1086 friend bool operator!=(const param_type& x, const param_type& y);
1089 // constructors and reset functions
1090 explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
1091 explicit normal_distribution(const param_type& parm);
1094 // generating functions
1095 template<class URNG> result_type operator()(URNG& g);
1096 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1098 // property functions
1099 result_type mean() const;
1100 result_type stddev() const;
1102 param_type param() const;
1103 void param(const param_type& parm);
1105 result_type min() const;
1106 result_type max() const;
1108 friend bool operator==(const normal_distribution& x,
1109 const normal_distribution& y);
1110 friend bool operator!=(const normal_distribution& x,
1111 const normal_distribution& y);
1113 template <class charT, class traits>
1115 basic_ostream<charT, traits>&
1116 operator<<(basic_ostream<charT, traits>& os,
1117 const normal_distribution& x);
1119 template <class charT, class traits>
1121 basic_istream<charT, traits>&
1122 operator>>(basic_istream<charT, traits>& is,
1123 normal_distribution& x);
1126 template<class RealType = double>
1127 class lognormal_distribution
1131 typedef RealType result_type;
1136 typedef lognormal_distribution distribution_type;
1138 explicit param_type(result_type m = 0, result_type s = 1);
1140 result_type m() const;
1141 result_type s() const;
1143 friend bool operator==(const param_type& x, const param_type& y);
1144 friend bool operator!=(const param_type& x, const param_type& y);
1147 // constructor and reset functions
1148 explicit lognormal_distribution(result_type m = 0, result_type s = 1);
1149 explicit lognormal_distribution(const param_type& parm);
1152 // generating functions
1153 template<class URNG> result_type operator()(URNG& g);
1154 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1156 // property functions
1157 result_type m() const;
1158 result_type s() const;
1160 param_type param() const;
1161 void param(const param_type& parm);
1163 result_type min() const;
1164 result_type max() const;
1166 friend bool operator==(const lognormal_distribution& x,
1167 const lognormal_distribution& y);
1168 friend bool operator!=(const lognormal_distribution& x,
1169 const lognormal_distribution& y);
1171 template <class charT, class traits>
1173 basic_ostream<charT, traits>&
1174 operator<<(basic_ostream<charT, traits>& os,
1175 const lognormal_distribution& x);
1177 template <class charT, class traits>
1179 basic_istream<charT, traits>&
1180 operator>>(basic_istream<charT, traits>& is,
1181 lognormal_distribution& x);
1184 template<class RealType = double>
1185 class chi_squared_distribution
1189 typedef RealType result_type;
1194 typedef chi_squared_distribution distribution_type;
1196 explicit param_type(result_type n = 1);
1198 result_type n() const;
1200 friend bool operator==(const param_type& x, const param_type& y);
1201 friend bool operator!=(const param_type& x, const param_type& y);
1204 // constructor and reset functions
1205 explicit chi_squared_distribution(result_type n = 1);
1206 explicit chi_squared_distribution(const param_type& parm);
1209 // generating functions
1210 template<class URNG> result_type operator()(URNG& g);
1211 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1213 // property functions
1214 result_type n() const;
1216 param_type param() const;
1217 void param(const param_type& parm);
1219 result_type min() const;
1220 result_type max() const;
1222 friend bool operator==(const chi_squared_distribution& x,
1223 const chi_squared_distribution& y);
1224 friend bool operator!=(const chi_squared_distribution& x,
1225 const chi_squared_distribution& y);
1227 template <class charT, class traits>
1229 basic_ostream<charT, traits>&
1230 operator<<(basic_ostream<charT, traits>& os,
1231 const chi_squared_distribution& x);
1233 template <class charT, class traits>
1235 basic_istream<charT, traits>&
1236 operator>>(basic_istream<charT, traits>& is,
1237 chi_squared_distribution& x);
1240 template<class RealType = double>
1241 class cauchy_distribution
1245 typedef RealType result_type;
1250 typedef cauchy_distribution distribution_type;
1252 explicit param_type(result_type a = 0, result_type b = 1);
1254 result_type a() const;
1255 result_type b() const;
1257 friend bool operator==(const param_type& x, const param_type& y);
1258 friend bool operator!=(const param_type& x, const param_type& y);
1261 // constructor and reset functions
1262 explicit cauchy_distribution(result_type a = 0, result_type b = 1);
1263 explicit cauchy_distribution(const param_type& parm);
1266 // generating functions
1267 template<class URNG> result_type operator()(URNG& g);
1268 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1270 // property functions
1271 result_type a() const;
1272 result_type b() const;
1274 param_type param() const;
1275 void param(const param_type& parm);
1277 result_type min() const;
1278 result_type max() const;
1280 friend bool operator==(const cauchy_distribution& x,
1281 const cauchy_distribution& y);
1282 friend bool operator!=(const cauchy_distribution& x,
1283 const cauchy_distribution& y);
1285 template <class charT, class traits>
1287 basic_ostream<charT, traits>&
1288 operator<<(basic_ostream<charT, traits>& os,
1289 const cauchy_distribution& x);
1291 template <class charT, class traits>
1293 basic_istream<charT, traits>&
1294 operator>>(basic_istream<charT, traits>& is,
1295 cauchy_distribution& x);
1298 template<class RealType = double>
1299 class fisher_f_distribution
1303 typedef RealType result_type;
1308 typedef fisher_f_distribution distribution_type;
1310 explicit param_type(result_type m = 1, result_type n = 1);
1312 result_type m() const;
1313 result_type n() const;
1315 friend bool operator==(const param_type& x, const param_type& y);
1316 friend bool operator!=(const param_type& x, const param_type& y);
1319 // constructor and reset functions
1320 explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
1321 explicit fisher_f_distribution(const param_type& parm);
1324 // generating functions
1325 template<class URNG> result_type operator()(URNG& g);
1326 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1328 // property functions
1329 result_type m() const;
1330 result_type n() const;
1332 param_type param() const;
1333 void param(const param_type& parm);
1335 result_type min() const;
1336 result_type max() const;
1338 friend bool operator==(const fisher_f_distribution& x,
1339 const fisher_f_distribution& y);
1340 friend bool operator!=(const fisher_f_distribution& x,
1341 const fisher_f_distribution& y);
1343 template <class charT, class traits>
1345 basic_ostream<charT, traits>&
1346 operator<<(basic_ostream<charT, traits>& os,
1347 const fisher_f_distribution& x);
1349 template <class charT, class traits>
1351 basic_istream<charT, traits>&
1352 operator>>(basic_istream<charT, traits>& is,
1353 fisher_f_distribution& x);
1356 template<class RealType = double>
1357 class student_t_distribution
1361 typedef RealType result_type;
1366 typedef student_t_distribution distribution_type;
1368 explicit param_type(result_type n = 1);
1370 result_type n() const;
1372 friend bool operator==(const param_type& x, const param_type& y);
1373 friend bool operator!=(const param_type& x, const param_type& y);
1376 // constructor and reset functions
1377 explicit student_t_distribution(result_type n = 1);
1378 explicit student_t_distribution(const param_type& parm);
1381 // generating functions
1382 template<class URNG> result_type operator()(URNG& g);
1383 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1385 // property functions
1386 result_type n() const;
1388 param_type param() const;
1389 void param(const param_type& parm);
1391 result_type min() const;
1392 result_type max() const;
1394 friend bool operator==(const student_t_distribution& x,
1395 const student_t_distribution& y);
1396 friend bool operator!=(const student_t_distribution& x,
1397 const student_t_distribution& y);
1399 template <class charT, class traits>
1401 basic_ostream<charT, traits>&
1402 operator<<(basic_ostream<charT, traits>& os,
1403 const student_t_distribution& x);
1405 template <class charT, class traits>
1407 basic_istream<charT, traits>&
1408 operator>>(basic_istream<charT, traits>& is,
1409 student_t_distribution& x);
1412 template<class IntType = int>
1413 class discrete_distribution
1417 typedef IntType result_type;
1422 typedef discrete_distribution distribution_type;
1425 template<class InputIterator>
1426 param_type(InputIterator firstW, InputIterator lastW);
1427 param_type(initializer_list<double> wl);
1428 template<class UnaryOperation>
1429 param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);
1431 vector<double> probabilities() const;
1433 friend bool operator==(const param_type& x, const param_type& y);
1434 friend bool operator!=(const param_type& x, const param_type& y);
1437 // constructor and reset functions
1438 discrete_distribution();
1439 template<class InputIterator>
1440 discrete_distribution(InputIterator firstW, InputIterator lastW);
1441 discrete_distribution(initializer_list<double> wl);
1442 template<class UnaryOperation>
1443 discrete_distribution(size_t nw, double xmin, double xmax,
1445 explicit discrete_distribution(const param_type& parm);
1448 // generating functions
1449 template<class URNG> result_type operator()(URNG& g);
1450 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1452 // property functions
1453 vector<double> probabilities() const;
1455 param_type param() const;
1456 void param(const param_type& parm);
1458 result_type min() const;
1459 result_type max() const;
1461 friend bool operator==(const discrete_distribution& x,
1462 const discrete_distribution& y);
1463 friend bool operator!=(const discrete_distribution& x,
1464 const discrete_distribution& y);
1466 template <class charT, class traits>
1468 basic_ostream<charT, traits>&
1469 operator<<(basic_ostream<charT, traits>& os,
1470 const discrete_distribution& x);
1472 template <class charT, class traits>
1474 basic_istream<charT, traits>&
1475 operator>>(basic_istream<charT, traits>& is,
1476 discrete_distribution& x);
1479 template<class RealType = double>
1480 class piecewise_constant_distribution
1483 typedef RealType result_type;
1488 typedef piecewise_constant_distribution distribution_type;
1491 template<class InputIteratorB, class InputIteratorW>
1492 param_type(InputIteratorB firstB, InputIteratorB lastB,
1493 InputIteratorW firstW);
1494 template<class UnaryOperation>
1495 param_type(initializer_list<result_type> bl, UnaryOperation fw);
1496 template<class UnaryOperation>
1497 param_type(size_t nw, result_type xmin, result_type xmax,
1500 vector<result_type> intervals() const;
1501 vector<result_type> densities() const;
1503 friend bool operator==(const param_type& x, const param_type& y);
1504 friend bool operator!=(const param_type& x, const param_type& y);
1507 // constructor and reset functions
1508 piecewise_constant_distribution();
1509 template<class InputIteratorB, class InputIteratorW>
1510 piecewise_constant_distribution(InputIteratorB firstB,
1511 InputIteratorB lastB,
1512 InputIteratorW firstW);
1513 template<class UnaryOperation>
1514 piecewise_constant_distribution(initializer_list<result_type> bl,
1516 template<class UnaryOperation>
1517 piecewise_constant_distribution(size_t nw, result_type xmin,
1518 result_type xmax, UnaryOperation fw);
1519 explicit piecewise_constant_distribution(const param_type& parm);
1522 // generating functions
1523 template<class URNG> result_type operator()(URNG& g);
1524 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1526 // property functions
1527 vector<result_type> intervals() const;
1528 vector<result_type> densities() const;
1530 param_type param() const;
1531 void param(const param_type& parm);
1533 result_type min() const;
1534 result_type max() const;
1536 friend bool operator==(const piecewise_constant_distribution& x,
1537 const piecewise_constant_distribution& y);
1538 friend bool operator!=(const piecewise_constant_distribution& x,
1539 const piecewise_constant_distribution& y);
1541 template <class charT, class traits>
1543 basic_ostream<charT, traits>&
1544 operator<<(basic_ostream<charT, traits>& os,
1545 const piecewise_constant_distribution& x);
1547 template <class charT, class traits>
1549 basic_istream<charT, traits>&
1550 operator>>(basic_istream<charT, traits>& is,
1551 piecewise_constant_distribution& x);
1554 template<class RealType = double>
1555 class piecewise_linear_distribution
1558 typedef RealType result_type;
1563 typedef piecewise_linear_distribution distribution_type;
1566 template<class InputIteratorB, class InputIteratorW>
1567 param_type(InputIteratorB firstB, InputIteratorB lastB,
1568 InputIteratorW firstW);
1569 template<class UnaryOperation>
1570 param_type(initializer_list<result_type> bl, UnaryOperation fw);
1571 template<class UnaryOperation>
1572 param_type(size_t nw, result_type xmin, result_type xmax,
1575 vector<result_type> intervals() const;
1576 vector<result_type> densities() const;
1578 friend bool operator==(const param_type& x, const param_type& y);
1579 friend bool operator!=(const param_type& x, const param_type& y);
1582 // constructor and reset functions
1583 piecewise_linear_distribution();
1584 template<class InputIteratorB, class InputIteratorW>
1585 piecewise_linear_distribution(InputIteratorB firstB,
1586 InputIteratorB lastB,
1587 InputIteratorW firstW);
1589 template<class UnaryOperation>
1590 piecewise_linear_distribution(initializer_list<result_type> bl,
1593 template<class UnaryOperation>
1594 piecewise_linear_distribution(size_t nw, result_type xmin,
1595 result_type xmax, UnaryOperation fw);
1597 explicit piecewise_linear_distribution(const param_type& parm);
1600 // generating functions
1601 template<class URNG> result_type operator()(URNG& g);
1602 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1604 // property functions
1605 vector<result_type> intervals() const;
1606 vector<result_type> densities() const;
1608 param_type param() const;
1609 void param(const param_type& parm);
1611 result_type min() const;
1612 result_type max() const;
1614 friend bool operator==(const piecewise_linear_distribution& x,
1615 const piecewise_linear_distribution& y);
1616 friend bool operator!=(const piecewise_linear_distribution& x,
1617 const piecewise_linear_distribution& y);
1619 template <class charT, class traits>
1621 basic_ostream<charT, traits>&
1622 operator<<(basic_ostream<charT, traits>& os,
1623 const piecewise_linear_distribution& x);
1625 template <class charT, class traits>
1627 basic_istream<charT, traits>&
1628 operator>>(basic_istream<charT, traits>& is,
1629 piecewise_linear_distribution& x);
1639 #include <type_traits>
1640 #include <initializer_list>
1642 #include <algorithm>
1649 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1650 #pragma GCC system_header
1654 #include <__undef_macros>
1657 _LIBCPP_BEGIN_NAMESPACE_STD
1659 // __is_seed_sequence
1661 template <class _Sseq, class _Engine>
1662 struct __is_seed_sequence
1664 static _LIBCPP_CONSTEXPR const bool value =
1665 !is_convertible<_Sseq, typename _Engine::result_type>::value &&
1666 !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
1669 // linear_congruential_engine
1671 template <unsigned long long __a, unsigned long long __c,
1672 unsigned long long __m, unsigned long long _Mp,
1673 bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a)>
1678 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
1679 struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true>
1681 typedef unsigned long long result_type;
1682 _LIBCPP_INLINE_VISIBILITY
1683 static result_type next(result_type __x)
1685 // Schrage's algorithm
1686 const result_type __q = __m / __a;
1687 const result_type __r = __m % __a;
1688 const result_type __t0 = __a * (__x % __q);
1689 const result_type __t1 = __r * (__x / __q);
1690 __x = __t0 + (__t0 < __t1) * __m - __t1;
1691 __x += __c - (__x >= __m - __c) * __m;
1696 template <unsigned long long __a, unsigned long long __m>
1697 struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true>
1699 typedef unsigned long long result_type;
1700 _LIBCPP_INLINE_VISIBILITY
1701 static result_type next(result_type __x)
1703 // Schrage's algorithm
1704 const result_type __q = __m / __a;
1705 const result_type __r = __m % __a;
1706 const result_type __t0 = __a * (__x % __q);
1707 const result_type __t1 = __r * (__x / __q);
1708 __x = __t0 + (__t0 < __t1) * __m - __t1;
1713 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
1714 struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false>
1716 typedef unsigned long long result_type;
1717 _LIBCPP_INLINE_VISIBILITY
1718 static result_type next(result_type __x)
1720 return (__a * __x + __c) % __m;
1724 template <unsigned long long __a, unsigned long long __c>
1725 struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false>
1727 typedef unsigned long long result_type;
1728 _LIBCPP_INLINE_VISIBILITY
1729 static result_type next(result_type __x)
1731 return __a * __x + __c;
1737 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
1738 struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true>
1740 typedef unsigned result_type;
1741 _LIBCPP_INLINE_VISIBILITY
1742 static result_type next(result_type __x)
1744 const result_type __a = static_cast<result_type>(_Ap);
1745 const result_type __c = static_cast<result_type>(_Cp);
1746 const result_type __m = static_cast<result_type>(_Mp);
1747 // Schrage's algorithm
1748 const result_type __q = __m / __a;
1749 const result_type __r = __m % __a;
1750 const result_type __t0 = __a * (__x % __q);
1751 const result_type __t1 = __r * (__x / __q);
1752 __x = __t0 + (__t0 < __t1) * __m - __t1;
1753 __x += __c - (__x >= __m - __c) * __m;
1758 template <unsigned long long _Ap, unsigned long long _Mp>
1759 struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true>
1761 typedef unsigned result_type;
1762 _LIBCPP_INLINE_VISIBILITY
1763 static result_type next(result_type __x)
1765 const result_type __a = static_cast<result_type>(_Ap);
1766 const result_type __m = static_cast<result_type>(_Mp);
1767 // Schrage's algorithm
1768 const result_type __q = __m / __a;
1769 const result_type __r = __m % __a;
1770 const result_type __t0 = __a * (__x % __q);
1771 const result_type __t1 = __r * (__x / __q);
1772 __x = __t0 + (__t0 < __t1) * __m - __t1;
1777 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
1778 struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false>
1780 typedef unsigned result_type;
1781 _LIBCPP_INLINE_VISIBILITY
1782 static result_type next(result_type __x)
1784 const result_type __a = static_cast<result_type>(_Ap);
1785 const result_type __c = static_cast<result_type>(_Cp);
1786 const result_type __m = static_cast<result_type>(_Mp);
1787 return (__a * __x + __c) % __m;
1791 template <unsigned long long _Ap, unsigned long long _Cp>
1792 struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false>
1794 typedef unsigned result_type;
1795 _LIBCPP_INLINE_VISIBILITY
1796 static result_type next(result_type __x)
1798 const result_type __a = static_cast<result_type>(_Ap);
1799 const result_type __c = static_cast<result_type>(_Cp);
1800 return __a * __x + __c;
1806 template <unsigned long long __a, unsigned long long __c, unsigned long long __m, bool __b>
1807 struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
1809 typedef unsigned short result_type;
1810 _LIBCPP_INLINE_VISIBILITY
1811 static result_type next(result_type __x)
1813 return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
1817 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1818 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;
1820 template <class _CharT, class _Traits,
1821 class _Up, _Up _Ap, _Up _Cp, _Up _Np>
1822 _LIBCPP_INLINE_VISIBILITY
1823 basic_ostream<_CharT, _Traits>&
1824 operator<<(basic_ostream<_CharT, _Traits>& __os,
1825 const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
1827 template <class _CharT, class _Traits,
1828 class _Up, _Up _Ap, _Up _Cp, _Up _Np>
1829 basic_istream<_CharT, _Traits>&
1830 operator>>(basic_istream<_CharT, _Traits>& __is,
1831 linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
1833 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1834 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
1838 typedef _UIntType result_type;
1843 static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
1845 static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
1846 static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
1848 static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
1849 static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
1850 static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");
1852 // engine characteristics
1853 static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
1854 static _LIBCPP_CONSTEXPR const result_type increment = __c;
1855 static _LIBCPP_CONSTEXPR const result_type modulus = __m;
1856 _LIBCPP_INLINE_VISIBILITY
1857 static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
1858 _LIBCPP_INLINE_VISIBILITY
1859 static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
1860 static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
1862 // constructors and seeding functions
1863 _LIBCPP_INLINE_VISIBILITY
1864 explicit linear_congruential_engine(result_type __s = default_seed)
1866 template<class _Sseq>
1867 _LIBCPP_INLINE_VISIBILITY
1868 explicit linear_congruential_engine(_Sseq& __q,
1869 typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
1871 _LIBCPP_INLINE_VISIBILITY
1872 void seed(result_type __s = default_seed)
1873 {seed(integral_constant<bool, __m == 0>(),
1874 integral_constant<bool, __c == 0>(), __s);}
1875 template<class _Sseq>
1876 _LIBCPP_INLINE_VISIBILITY
1879 __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
1883 {__seed(__q, integral_constant<unsigned,
1884 1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
1885 : (__m > 0x100000000ull))>());}
1887 // generating functions
1888 _LIBCPP_INLINE_VISIBILITY
1889 result_type operator()()
1890 {return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
1891 _LIBCPP_INLINE_VISIBILITY
1892 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
1894 friend _LIBCPP_INLINE_VISIBILITY
1895 bool operator==(const linear_congruential_engine& __x,
1896 const linear_congruential_engine& __y)
1897 {return __x.__x_ == __y.__x_;}
1898 friend _LIBCPP_INLINE_VISIBILITY
1899 bool operator!=(const linear_congruential_engine& __x,
1900 const linear_congruential_engine& __y)
1901 {return !(__x == __y);}
1905 _LIBCPP_INLINE_VISIBILITY
1906 void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
1907 _LIBCPP_INLINE_VISIBILITY
1908 void seed(true_type, false_type, result_type __s) {__x_ = __s;}
1909 _LIBCPP_INLINE_VISIBILITY
1910 void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
1912 _LIBCPP_INLINE_VISIBILITY
1913 void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
1915 template<class _Sseq>
1916 void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
1917 template<class _Sseq>
1918 void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
1920 template <class _CharT, class _Traits,
1921 class _Up, _Up _Ap, _Up _Cp, _Up _Np>
1923 basic_ostream<_CharT, _Traits>&
1924 operator<<(basic_ostream<_CharT, _Traits>& __os,
1925 const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
1927 template <class _CharT, class _Traits,
1928 class _Up, _Up _Ap, _Up _Cp, _Up _Np>
1930 basic_istream<_CharT, _Traits>&
1931 operator>>(basic_istream<_CharT, _Traits>& __is,
1932 linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
1935 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1936 _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
1937 linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
1939 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1940 _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
1941 linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
1943 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1944 _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
1945 linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
1947 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1948 _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
1949 linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
1951 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1952 template<class _Sseq>
1954 linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
1955 integral_constant<unsigned, 1>)
1957 const unsigned __k = 1;
1958 uint32_t __ar[__k+3];
1959 __q.generate(__ar, __ar + __k + 3);
1960 result_type __s = static_cast<result_type>(__ar[3] % __m);
1961 __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
1964 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1965 template<class _Sseq>
1967 linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
1968 integral_constant<unsigned, 2>)
1970 const unsigned __k = 2;
1971 uint32_t __ar[__k+3];
1972 __q.generate(__ar, __ar + __k + 3);
1973 result_type __s = static_cast<result_type>((__ar[3] +
1974 ((uint64_t)__ar[4] << 32)) % __m);
1975 __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
1978 template <class _CharT, class _Traits,
1979 class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1980 inline _LIBCPP_INLINE_VISIBILITY
1981 basic_ostream<_CharT, _Traits>&
1982 operator<<(basic_ostream<_CharT, _Traits>& __os,
1983 const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
1985 __save_flags<_CharT, _Traits> __lx(__os);
1986 __os.flags(ios_base::dec | ios_base::left);
1987 __os.fill(__os.widen(' '));
1988 return __os << __x.__x_;
1991 template <class _CharT, class _Traits,
1992 class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
1993 basic_istream<_CharT, _Traits>&
1994 operator>>(basic_istream<_CharT, _Traits>& __is,
1995 linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
1997 __save_flags<_CharT, _Traits> __lx(__is);
1998 __is.flags(ios_base::dec | ios_base::skipws);
2006 typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
2008 typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
2010 typedef minstd_rand default_random_engine;
2011 // mersenne_twister_engine
2013 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2014 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2015 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2016 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
2018 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2019 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2020 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2022 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2023 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2024 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2025 _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
2027 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2028 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2029 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2030 _LIBCPP_INLINE_VISIBILITY
2032 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2033 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2034 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2035 _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
2037 template <class _CharT, class _Traits,
2038 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2039 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2040 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2041 basic_ostream<_CharT, _Traits>&
2042 operator<<(basic_ostream<_CharT, _Traits>& __os,
2043 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2044 _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
2046 template <class _CharT, class _Traits,
2047 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2048 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2049 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2050 basic_istream<_CharT, _Traits>&
2051 operator>>(basic_istream<_CharT, _Traits>& __is,
2052 mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2053 _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
2055 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2056 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2057 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2058 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
2062 typedef _UIntType result_type;
2065 result_type __x_[__n];
2068 static_assert( 0 < __m, "mersenne_twister_engine invalid parameters");
2069 static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
2070 static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
2071 static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
2072 static_assert( 2 <= __w, "mersenne_twister_engine invalid parameters");
2073 static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
2074 static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
2075 static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
2076 static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
2077 static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
2079 static _LIBCPP_CONSTEXPR const result_type _Min = 0;
2080 static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
2081 (result_type(1) << __w) - result_type(1);
2082 static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
2083 static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
2084 static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
2085 static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
2086 static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
2087 static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
2089 // engine characteristics
2090 static _LIBCPP_CONSTEXPR const size_t word_size = __w;
2091 static _LIBCPP_CONSTEXPR const size_t state_size = __n;
2092 static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
2093 static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
2094 static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
2095 static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
2096 static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
2097 static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
2098 static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
2099 static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
2100 static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
2101 static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
2102 static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
2103 _LIBCPP_INLINE_VISIBILITY
2104 static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
2105 _LIBCPP_INLINE_VISIBILITY
2106 static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
2107 static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
2109 // constructors and seeding functions
2110 _LIBCPP_INLINE_VISIBILITY
2111 explicit mersenne_twister_engine(result_type __sd = default_seed)
2113 template<class _Sseq>
2114 _LIBCPP_INLINE_VISIBILITY
2115 explicit mersenne_twister_engine(_Sseq& __q,
2116 typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
2118 void seed(result_type __sd = default_seed);
2119 template<class _Sseq>
2120 _LIBCPP_INLINE_VISIBILITY
2123 __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
2127 {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
2129 // generating functions
2130 result_type operator()();
2131 _LIBCPP_INLINE_VISIBILITY
2132 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
2134 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2135 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2136 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2139 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2140 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2141 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2142 _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
2144 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2145 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2146 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2149 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2150 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2151 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2152 _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
2154 template <class _CharT, class _Traits,
2155 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2156 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2157 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2159 basic_ostream<_CharT, _Traits>&
2160 operator<<(basic_ostream<_CharT, _Traits>& __os,
2161 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2162 _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
2164 template <class _CharT, class _Traits,
2165 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2166 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2167 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2169 basic_istream<_CharT, _Traits>&
2170 operator>>(basic_istream<_CharT, _Traits>& __is,
2171 mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2172 _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
2175 template<class _Sseq>
2176 void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
2177 template<class _Sseq>
2178 void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
2180 template <size_t __count>
2181 _LIBCPP_INLINE_VISIBILITY
2188 __lshift(result_type __x) {return (__x << __count) & _Max;}
2190 template <size_t __count>
2191 _LIBCPP_INLINE_VISIBILITY
2198 __lshift(result_type) {return result_type(0);}
2200 template <size_t __count>
2201 _LIBCPP_INLINE_VISIBILITY
2208 __rshift(result_type __x) {return __x >> __count;}
2210 template <size_t __count>
2211 _LIBCPP_INLINE_VISIBILITY
2218 __rshift(result_type) {return result_type(0);}
2221 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2222 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2223 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2224 _LIBCPP_CONSTEXPR const size_t
2225 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
2227 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2228 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2229 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2230 _LIBCPP_CONSTEXPR const size_t
2231 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
2233 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2234 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2235 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2236 _LIBCPP_CONSTEXPR const size_t
2237 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
2239 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2240 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2241 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2242 _LIBCPP_CONSTEXPR const size_t
2243 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
2245 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2246 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2247 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2248 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2249 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
2251 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2252 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2253 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2254 _LIBCPP_CONSTEXPR const size_t
2255 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
2257 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2258 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2259 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2260 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2261 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
2263 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2264 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2265 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2266 _LIBCPP_CONSTEXPR const size_t
2267 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
2269 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2270 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2271 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2272 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2273 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
2275 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2276 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2277 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2278 _LIBCPP_CONSTEXPR const size_t
2279 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
2281 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2282 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2283 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2284 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2285 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
2287 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2288 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2289 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2290 _LIBCPP_CONSTEXPR const size_t
2291 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
2293 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2294 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2295 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2296 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2297 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
2299 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2300 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2301 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2302 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
2303 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
2305 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2306 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2307 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2309 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
2310 __t, __c, __l, __f>::seed(result_type __sd)
2312 __x_[0] = __sd & _Max;
2313 for (size_t __i = 1; __i < __n; ++__i)
2314 __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
2318 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2319 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2320 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2321 template<class _Sseq>
2323 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
2324 __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
2326 const unsigned __k = 1;
2327 uint32_t __ar[__n * __k];
2328 __q.generate(__ar, __ar + __n * __k);
2329 for (size_t __i = 0; __i < __n; ++__i)
2330 __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
2331 const result_type __mask = __r == _Dt ? result_type(~0) :
2332 (result_type(1) << __r) - result_type(1);
2334 if ((__x_[0] & ~__mask) == 0)
2336 for (size_t __i = 1; __i < __n; ++__i)
2343 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2344 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2345 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2346 template<class _Sseq>
2348 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
2349 __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
2351 const unsigned __k = 2;
2352 uint32_t __ar[__n * __k];
2353 __q.generate(__ar, __ar + __n * __k);
2354 for (size_t __i = 0; __i < __n; ++__i)
2355 __x_[__i] = static_cast<result_type>(
2356 (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
2357 const result_type __mask = __r == _Dt ? result_type(~0) :
2358 (result_type(1) << __r) - result_type(1);
2360 if ((__x_[0] & ~__mask) == 0)
2362 for (size_t __i = 1; __i < __n; ++__i)
2369 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
2370 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
2371 _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
2373 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
2374 __t, __c, __l, __f>::operator()()
2376 const size_t __j = (__i_ + 1) % __n;
2377 const result_type __mask = __r == _Dt ? result_type(~0) :
2378 (result_type(1) << __r) - result_type(1);
2379 const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
2380 const size_t __k = (__i_ + __m) % __n;
2381 __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
2382 result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
2384 __z ^= __lshift<__s>(__z) & __b;
2385 __z ^= __lshift<__t>(__z) & __c;
2386 return __z ^ __rshift<__l>(__z);
2389 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2390 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2391 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2393 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2394 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2395 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2396 _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
2398 if (__x.__i_ == __y.__i_)
2399 return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
2400 if (__x.__i_ == 0 || __y.__i_ == 0)
2402 size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
2403 if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
2404 __y.__x_ + __y.__i_))
2407 return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
2408 return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
2410 if (__x.__i_ < __y.__i_)
2412 size_t __j = _Np - __y.__i_;
2413 if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
2414 __y.__x_ + __y.__i_))
2416 if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
2419 return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
2420 __y.__x_ + (_Np - (__x.__i_ + __j)));
2422 size_t __j = _Np - __x.__i_;
2423 if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
2424 __x.__x_ + __x.__i_))
2426 if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
2429 return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
2430 __x.__x_ + (_Np - (__y.__i_ + __j)));
2433 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2434 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2435 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2436 inline _LIBCPP_INLINE_VISIBILITY
2438 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2439 _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
2440 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2441 _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
2443 return !(__x == __y);
2446 template <class _CharT, class _Traits,
2447 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2448 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2449 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2450 basic_ostream<_CharT, _Traits>&
2451 operator<<(basic_ostream<_CharT, _Traits>& __os,
2452 const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2453 _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
2455 __save_flags<_CharT, _Traits> __lx(__os);
2456 __os.flags(ios_base::dec | ios_base::left);
2457 _CharT __sp = __os.widen(' ');
2459 __os << __x.__x_[__x.__i_];
2460 for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
2461 __os << __sp << __x.__x_[__j];
2462 for (size_t __j = 0; __j < __x.__i_; ++__j)
2463 __os << __sp << __x.__x_[__j];
2467 template <class _CharT, class _Traits,
2468 class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
2469 _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
2470 _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
2471 basic_istream<_CharT, _Traits>&
2472 operator>>(basic_istream<_CharT, _Traits>& __is,
2473 mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
2474 _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
2476 __save_flags<_CharT, _Traits> __lx(__is);
2477 __is.flags(ios_base::dec | ios_base::skipws);
2479 for (size_t __i = 0; __i < _Np; ++__i)
2483 for (size_t __i = 0; __i < _Np; ++__i)
2484 __x.__x_[__i] = __t[__i];
2490 typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
2491 0x9908b0df, 11, 0xffffffff,
2494 18, 1812433253> mt19937;
2495 typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
2496 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
2497 17, 0x71d67fffeda60000ULL,
2498 37, 0xfff7eee000000000ULL,
2499 43, 6364136223846793005ULL> mt19937_64;
2501 // subtract_with_carry_engine
2503 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2504 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
2506 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2509 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2510 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
2512 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2513 _LIBCPP_INLINE_VISIBILITY
2516 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2517 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
2519 template <class _CharT, class _Traits,
2520 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2521 basic_ostream<_CharT, _Traits>&
2522 operator<<(basic_ostream<_CharT, _Traits>& __os,
2523 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
2525 template <class _CharT, class _Traits,
2526 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2527 basic_istream<_CharT, _Traits>&
2528 operator>>(basic_istream<_CharT, _Traits>& __is,
2529 subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
2531 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2532 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
2536 typedef _UIntType result_type;
2539 result_type __x_[__r];
2543 static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
2544 static_assert( 0 < __w, "subtract_with_carry_engine invalid parameters");
2545 static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
2546 static_assert( 0 < __s, "subtract_with_carry_engine invalid parameters");
2547 static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
2549 static _LIBCPP_CONSTEXPR const result_type _Min = 0;
2550 static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
2551 (result_type(1) << __w) - result_type(1);
2552 static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
2554 // engine characteristics
2555 static _LIBCPP_CONSTEXPR const size_t word_size = __w;
2556 static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
2557 static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
2558 _LIBCPP_INLINE_VISIBILITY
2559 static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
2560 _LIBCPP_INLINE_VISIBILITY
2561 static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
2562 static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
2564 // constructors and seeding functions
2565 _LIBCPP_INLINE_VISIBILITY
2566 explicit subtract_with_carry_engine(result_type __sd = default_seed)
2568 template<class _Sseq>
2569 _LIBCPP_INLINE_VISIBILITY
2570 explicit subtract_with_carry_engine(_Sseq& __q,
2571 typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
2573 _LIBCPP_INLINE_VISIBILITY
2574 void seed(result_type __sd = default_seed)
2575 {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
2576 template<class _Sseq>
2577 _LIBCPP_INLINE_VISIBILITY
2580 __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
2584 {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
2586 // generating functions
2587 result_type operator()();
2588 _LIBCPP_INLINE_VISIBILITY
2589 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
2591 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2595 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2596 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
2598 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2602 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2603 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
2605 template <class _CharT, class _Traits,
2606 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2608 basic_ostream<_CharT, _Traits>&
2609 operator<<(basic_ostream<_CharT, _Traits>& __os,
2610 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
2612 template <class _CharT, class _Traits,
2613 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2615 basic_istream<_CharT, _Traits>&
2616 operator>>(basic_istream<_CharT, _Traits>& __is,
2617 subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
2621 void seed(result_type __sd, integral_constant<unsigned, 1>);
2622 void seed(result_type __sd, integral_constant<unsigned, 2>);
2623 template<class _Sseq>
2624 void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
2625 template<class _Sseq>
2626 void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
2629 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2630 _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
2632 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2633 _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
2635 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2636 _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
2638 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2639 _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
2640 subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
2642 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2644 subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
2645 integral_constant<unsigned, 1>)
2647 linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
2648 __e(__sd == 0u ? default_seed : __sd);
2649 for (size_t __i = 0; __i < __r; ++__i)
2650 __x_[__i] = static_cast<result_type>(__e() & _Max);
2651 __c_ = __x_[__r-1] == 0;
2655 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2657 subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
2658 integral_constant<unsigned, 2>)
2660 linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
2661 __e(__sd == 0u ? default_seed : __sd);
2662 for (size_t __i = 0; __i < __r; ++__i)
2664 result_type __e0 = __e();
2665 __x_[__i] = static_cast<result_type>(
2666 (__e0 + ((uint64_t)__e() << 32)) & _Max);
2668 __c_ = __x_[__r-1] == 0;
2672 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2673 template<class _Sseq>
2675 subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
2676 integral_constant<unsigned, 1>)
2678 const unsigned __k = 1;
2679 uint32_t __ar[__r * __k];
2680 __q.generate(__ar, __ar + __r * __k);
2681 for (size_t __i = 0; __i < __r; ++__i)
2682 __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
2683 __c_ = __x_[__r-1] == 0;
2687 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2688 template<class _Sseq>
2690 subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
2691 integral_constant<unsigned, 2>)
2693 const unsigned __k = 2;
2694 uint32_t __ar[__r * __k];
2695 __q.generate(__ar, __ar + __r * __k);
2696 for (size_t __i = 0; __i < __r; ++__i)
2697 __x_[__i] = static_cast<result_type>(
2698 (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
2699 __c_ = __x_[__r-1] == 0;
2703 template<class _UIntType, size_t __w, size_t __s, size_t __r>
2705 subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
2707 const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
2708 result_type& __xr = __x_[__i_];
2709 result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
2710 __xr = (__xs - __xr - __c_) & _Max;
2712 __i_ = (__i_ + 1) % __r;
2716 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2719 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2720 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
2722 if (__x.__c_ != __y.__c_)
2724 if (__x.__i_ == __y.__i_)
2725 return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
2726 if (__x.__i_ == 0 || __y.__i_ == 0)
2728 size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
2729 if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
2730 __y.__x_ + __y.__i_))
2733 return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
2734 return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
2736 if (__x.__i_ < __y.__i_)
2738 size_t __j = _Rp - __y.__i_;
2739 if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
2740 __y.__x_ + __y.__i_))
2742 if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
2745 return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
2746 __y.__x_ + (_Rp - (__x.__i_ + __j)));
2748 size_t __j = _Rp - __x.__i_;
2749 if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
2750 __x.__x_ + __x.__i_))
2752 if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
2755 return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
2756 __x.__x_ + (_Rp - (__y.__i_ + __j)));
2759 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2760 inline _LIBCPP_INLINE_VISIBILITY
2763 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
2764 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
2766 return !(__x == __y);
2769 template <class _CharT, class _Traits,
2770 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2771 basic_ostream<_CharT, _Traits>&
2772 operator<<(basic_ostream<_CharT, _Traits>& __os,
2773 const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
2775 __save_flags<_CharT, _Traits> __lx(__os);
2776 __os.flags(ios_base::dec | ios_base::left);
2777 _CharT __sp = __os.widen(' ');
2779 __os << __x.__x_[__x.__i_];
2780 for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
2781 __os << __sp << __x.__x_[__j];
2782 for (size_t __j = 0; __j < __x.__i_; ++__j)
2783 __os << __sp << __x.__x_[__j];
2784 __os << __sp << __x.__c_;
2788 template <class _CharT, class _Traits,
2789 class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
2790 basic_istream<_CharT, _Traits>&
2791 operator>>(basic_istream<_CharT, _Traits>& __is,
2792 subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
2794 __save_flags<_CharT, _Traits> __lx(__is);
2795 __is.flags(ios_base::dec | ios_base::skipws);
2797 for (size_t __i = 0; __i < _Rp+1; ++__i)
2801 for (size_t __i = 0; __i < _Rp; ++__i)
2802 __x.__x_[__i] = __t[__i];
2803 __x.__c_ = __t[_Rp];
2809 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
2810 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
2812 // discard_block_engine
2814 template<class _Engine, size_t __p, size_t __r>
2815 class _LIBCPP_TEMPLATE_VIS discard_block_engine
2820 static_assert( 0 < __r, "discard_block_engine invalid parameters");
2821 static_assert(__r <= __p, "discard_block_engine invalid parameters");
2822 static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters");
2825 typedef typename _Engine::result_type result_type;
2827 // engine characteristics
2828 static _LIBCPP_CONSTEXPR const size_t block_size = __p;
2829 static _LIBCPP_CONSTEXPR const size_t used_block = __r;
2831 #ifdef _LIBCPP_CXX03_LANG
2832 static const result_type _Min = _Engine::_Min;
2833 static const result_type _Max = _Engine::_Max;
2835 static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
2836 static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
2839 _LIBCPP_INLINE_VISIBILITY
2840 static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
2841 _LIBCPP_INLINE_VISIBILITY
2842 static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
2844 // constructors and seeding functions
2845 _LIBCPP_INLINE_VISIBILITY
2846 discard_block_engine() : __n_(0) {}
2847 _LIBCPP_INLINE_VISIBILITY
2848 explicit discard_block_engine(const _Engine& __e)
2849 : __e_(__e), __n_(0) {}
2850 #ifndef _LIBCPP_CXX03_LANG
2851 _LIBCPP_INLINE_VISIBILITY
2852 explicit discard_block_engine(_Engine&& __e)
2853 : __e_(_VSTD::move(__e)), __n_(0) {}
2854 #endif // _LIBCPP_CXX03_LANG
2855 _LIBCPP_INLINE_VISIBILITY
2856 explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
2857 template<class _Sseq>
2858 _LIBCPP_INLINE_VISIBILITY
2859 explicit discard_block_engine(_Sseq& __q,
2860 typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
2861 !is_convertible<_Sseq, _Engine>::value>::type* = 0)
2862 : __e_(__q), __n_(0) {}
2863 _LIBCPP_INLINE_VISIBILITY
2864 void seed() {__e_.seed(); __n_ = 0;}
2865 _LIBCPP_INLINE_VISIBILITY
2866 void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
2867 template<class _Sseq>
2868 _LIBCPP_INLINE_VISIBILITY
2871 __is_seed_sequence<_Sseq, discard_block_engine>::value,
2874 seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
2876 // generating functions
2877 result_type operator()();
2878 _LIBCPP_INLINE_VISIBILITY
2879 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
2881 // property functions
2882 _LIBCPP_INLINE_VISIBILITY
2883 const _Engine& base() const _NOEXCEPT {return __e_;}
2885 template<class _Eng, size_t _Pp, size_t _Rp>
2889 const discard_block_engine<_Eng, _Pp, _Rp>& __x,
2890 const discard_block_engine<_Eng, _Pp, _Rp>& __y);
2892 template<class _Eng, size_t _Pp, size_t _Rp>
2896 const discard_block_engine<_Eng, _Pp, _Rp>& __x,
2897 const discard_block_engine<_Eng, _Pp, _Rp>& __y);
2899 template <class _CharT, class _Traits,
2900 class _Eng, size_t _Pp, size_t _Rp>
2902 basic_ostream<_CharT, _Traits>&
2903 operator<<(basic_ostream<_CharT, _Traits>& __os,
2904 const discard_block_engine<_Eng, _Pp, _Rp>& __x);
2906 template <class _CharT, class _Traits,
2907 class _Eng, size_t _Pp, size_t _Rp>
2909 basic_istream<_CharT, _Traits>&
2910 operator>>(basic_istream<_CharT, _Traits>& __is,
2911 discard_block_engine<_Eng, _Pp, _Rp>& __x);
2914 template<class _Engine, size_t __p, size_t __r>
2915 _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
2917 template<class _Engine, size_t __p, size_t __r>
2918 _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
2920 template<class _Engine, size_t __p, size_t __r>
2921 typename discard_block_engine<_Engine, __p, __r>::result_type
2922 discard_block_engine<_Engine, __p, __r>::operator()()
2924 if (__n_ >= static_cast<int>(__r))
2926 __e_.discard(__p - __r);
2933 template<class _Eng, size_t _Pp, size_t _Rp>
2934 inline _LIBCPP_INLINE_VISIBILITY
2936 operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
2937 const discard_block_engine<_Eng, _Pp, _Rp>& __y)
2939 return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
2942 template<class _Eng, size_t _Pp, size_t _Rp>
2943 inline _LIBCPP_INLINE_VISIBILITY
2945 operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
2946 const discard_block_engine<_Eng, _Pp, _Rp>& __y)
2948 return !(__x == __y);
2951 template <class _CharT, class _Traits,
2952 class _Eng, size_t _Pp, size_t _Rp>
2953 basic_ostream<_CharT, _Traits>&
2954 operator<<(basic_ostream<_CharT, _Traits>& __os,
2955 const discard_block_engine<_Eng, _Pp, _Rp>& __x)
2957 __save_flags<_CharT, _Traits> __lx(__os);
2958 __os.flags(ios_base::dec | ios_base::left);
2959 _CharT __sp = __os.widen(' ');
2961 return __os << __x.__e_ << __sp << __x.__n_;
2964 template <class _CharT, class _Traits,
2965 class _Eng, size_t _Pp, size_t _Rp>
2966 basic_istream<_CharT, _Traits>&
2967 operator>>(basic_istream<_CharT, _Traits>& __is,
2968 discard_block_engine<_Eng, _Pp, _Rp>& __x)
2970 __save_flags<_CharT, _Traits> __lx(__is);
2971 __is.flags(ios_base::dec | ios_base::skipws);
2983 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
2984 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
2986 // independent_bits_engine
2988 template<class _Engine, size_t __w, class _UIntType>
2989 class _LIBCPP_TEMPLATE_VIS independent_bits_engine
2991 template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
2994 static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
2995 static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
2996 static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
2997 static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
2999 static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
3003 typedef _UIntType result_type;
3008 static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
3009 static_assert( 0 < __w, "independent_bits_engine invalid parameters");
3010 static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
3012 typedef typename _Engine::result_type _Engine_result_type;
3013 typedef typename conditional
3015 sizeof(_Engine_result_type) <= sizeof(result_type),
3018 >::type _Working_result_type;
3019 #ifdef _LIBCPP_CXX03_LANG
3020 static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
3021 + _Working_result_type(1);
3023 static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
3024 + _Working_result_type(1);
3026 static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
3027 static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
3028 static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
3029 static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
3030 static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
3031 static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
3032 static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
3033 (_Rp >> __w0) << __w0;
3034 static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
3035 (_Rp >> (__w0+1)) << (__w0+1);
3036 static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
3037 _Engine_result_type(~0) >> (_EDt - __w0) :
3038 _Engine_result_type(0);
3039 static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
3040 _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
3041 _Engine_result_type(~0);
3043 static _LIBCPP_CONSTEXPR const result_type _Min = 0;
3044 static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
3045 (result_type(1) << __w) - result_type(1);
3046 static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
3048 // engine characteristics
3049 _LIBCPP_INLINE_VISIBILITY
3050 static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
3051 _LIBCPP_INLINE_VISIBILITY
3052 static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
3054 // constructors and seeding functions
3055 _LIBCPP_INLINE_VISIBILITY
3056 independent_bits_engine() {}
3057 _LIBCPP_INLINE_VISIBILITY
3058 explicit independent_bits_engine(const _Engine& __e)
3060 #ifndef _LIBCPP_CXX03_LANG
3061 _LIBCPP_INLINE_VISIBILITY
3062 explicit independent_bits_engine(_Engine&& __e)
3063 : __e_(_VSTD::move(__e)) {}
3064 #endif // _LIBCPP_CXX03_LANG
3065 _LIBCPP_INLINE_VISIBILITY
3066 explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
3067 template<class _Sseq>
3068 _LIBCPP_INLINE_VISIBILITY
3069 explicit independent_bits_engine(_Sseq& __q,
3070 typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
3071 !is_convertible<_Sseq, _Engine>::value>::type* = 0)
3073 _LIBCPP_INLINE_VISIBILITY
3074 void seed() {__e_.seed();}
3075 _LIBCPP_INLINE_VISIBILITY
3076 void seed(result_type __sd) {__e_.seed(__sd);}
3077 template<class _Sseq>
3078 _LIBCPP_INLINE_VISIBILITY
3081 __is_seed_sequence<_Sseq, independent_bits_engine>::value,
3084 seed(_Sseq& __q) {__e_.seed(__q);}
3086 // generating functions
3087 _LIBCPP_INLINE_VISIBILITY
3088 result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
3089 _LIBCPP_INLINE_VISIBILITY
3090 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
3092 // property functions
3093 _LIBCPP_INLINE_VISIBILITY
3094 const _Engine& base() const _NOEXCEPT {return __e_;}
3096 template<class _Eng, size_t _Wp, class _UInt>
3100 const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
3101 const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
3103 template<class _Eng, size_t _Wp, class _UInt>
3107 const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
3108 const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
3110 template <class _CharT, class _Traits,
3111 class _Eng, size_t _Wp, class _UInt>
3113 basic_ostream<_CharT, _Traits>&
3114 operator<<(basic_ostream<_CharT, _Traits>& __os,
3115 const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
3117 template <class _CharT, class _Traits,
3118 class _Eng, size_t _Wp, class _UInt>
3120 basic_istream<_CharT, _Traits>&
3121 operator>>(basic_istream<_CharT, _Traits>& __is,
3122 independent_bits_engine<_Eng, _Wp, _UInt>& __x);
3125 _LIBCPP_INLINE_VISIBILITY
3126 result_type __eval(false_type);
3127 result_type __eval(true_type);
3129 template <size_t __count>
3130 _LIBCPP_INLINE_VISIBILITY
3137 __lshift(result_type __x) {return __x << __count;}
3139 template <size_t __count>
3140 _LIBCPP_INLINE_VISIBILITY
3147 __lshift(result_type) {return result_type(0);}
3150 template<class _Engine, size_t __w, class _UIntType>
3153 independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
3155 return static_cast<result_type>(__e_() & __mask0);
3158 template<class _Engine, size_t __w, class _UIntType>
3160 independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
3162 result_type _Sp = 0;
3163 for (size_t __k = 0; __k < __n0; ++__k)
3165 _Engine_result_type __u;
3168 __u = __e_() - _Engine::min();
3169 } while (__u >= __y0);
3170 _Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
3172 for (size_t __k = __n0; __k < __n; ++__k)
3174 _Engine_result_type __u;
3177 __u = __e_() - _Engine::min();
3178 } while (__u >= __y1);
3179 _Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
3184 template<class _Eng, size_t _Wp, class _UInt>
3185 inline _LIBCPP_INLINE_VISIBILITY
3188 const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
3189 const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
3191 return __x.base() == __y.base();
3194 template<class _Eng, size_t _Wp, class _UInt>
3195 inline _LIBCPP_INLINE_VISIBILITY
3198 const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
3199 const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
3201 return !(__x == __y);
3204 template <class _CharT, class _Traits,
3205 class _Eng, size_t _Wp, class _UInt>
3206 basic_ostream<_CharT, _Traits>&
3207 operator<<(basic_ostream<_CharT, _Traits>& __os,
3208 const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
3210 return __os << __x.base();
3213 template <class _CharT, class _Traits,
3214 class _Eng, size_t _Wp, class _UInt>
3215 basic_istream<_CharT, _Traits>&
3216 operator>>(basic_istream<_CharT, _Traits>& __is,
3217 independent_bits_engine<_Eng, _Wp, _UInt>& __x)
3226 // shuffle_order_engine
3228 template <uint64_t _Xp, uint64_t _Yp>
3231 static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
3234 template <uint64_t _Xp>
3235 struct __ugcd<_Xp, 0>
3237 static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
3240 template <uint64_t _Np, uint64_t _Dp>
3243 static_assert(_Dp != 0, "__uratio divide by 0");
3244 static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
3246 static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
3247 static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
3249 typedef __uratio<num, den> type;
3252 template<class _Engine, size_t __k>
3253 class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
3255 static_assert(0 < __k, "shuffle_order_engine invalid parameters");
3258 typedef typename _Engine::result_type result_type;
3262 result_type _V_[__k];
3266 // engine characteristics
3267 static _LIBCPP_CONSTEXPR const size_t table_size = __k;
3269 #ifdef _LIBCPP_CXX03_LANG
3270 static const result_type _Min = _Engine::_Min;
3271 static const result_type _Max = _Engine::_Max;
3273 static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
3274 static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
3276 static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
3277 _LIBCPP_INLINE_VISIBILITY
3278 static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
3279 _LIBCPP_INLINE_VISIBILITY
3280 static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
3282 static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
3284 // constructors and seeding functions
3285 _LIBCPP_INLINE_VISIBILITY
3286 shuffle_order_engine() {__init();}
3287 _LIBCPP_INLINE_VISIBILITY
3288 explicit shuffle_order_engine(const _Engine& __e)
3289 : __e_(__e) {__init();}
3290 #ifndef _LIBCPP_CXX03_LANG
3291 _LIBCPP_INLINE_VISIBILITY
3292 explicit shuffle_order_engine(_Engine&& __e)
3293 : __e_(_VSTD::move(__e)) {__init();}
3294 #endif // _LIBCPP_CXX03_LANG
3295 _LIBCPP_INLINE_VISIBILITY
3296 explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
3297 template<class _Sseq>
3298 _LIBCPP_INLINE_VISIBILITY
3299 explicit shuffle_order_engine(_Sseq& __q,
3300 typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
3301 !is_convertible<_Sseq, _Engine>::value>::type* = 0)
3302 : __e_(__q) {__init();}
3303 _LIBCPP_INLINE_VISIBILITY
3304 void seed() {__e_.seed(); __init();}
3305 _LIBCPP_INLINE_VISIBILITY
3306 void seed(result_type __sd) {__e_.seed(__sd); __init();}
3307 template<class _Sseq>
3308 _LIBCPP_INLINE_VISIBILITY
3311 __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
3314 seed(_Sseq& __q) {__e_.seed(__q); __init();}
3316 // generating functions
3317 _LIBCPP_INLINE_VISIBILITY
3318 result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
3319 _LIBCPP_INLINE_VISIBILITY
3320 void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
3322 // property functions
3323 _LIBCPP_INLINE_VISIBILITY
3324 const _Engine& base() const _NOEXCEPT {return __e_;}
3327 template<class _Eng, size_t _Kp>
3331 const shuffle_order_engine<_Eng, _Kp>& __x,
3332 const shuffle_order_engine<_Eng, _Kp>& __y);
3334 template<class _Eng, size_t _Kp>
3338 const shuffle_order_engine<_Eng, _Kp>& __x,
3339 const shuffle_order_engine<_Eng, _Kp>& __y);
3341 template <class _CharT, class _Traits,
3342 class _Eng, size_t _Kp>
3344 basic_ostream<_CharT, _Traits>&
3345 operator<<(basic_ostream<_CharT, _Traits>& __os,
3346 const shuffle_order_engine<_Eng, _Kp>& __x);
3348 template <class _CharT, class _Traits,
3349 class _Eng, size_t _Kp>
3351 basic_istream<_CharT, _Traits>&
3352 operator>>(basic_istream<_CharT, _Traits>& __is,
3353 shuffle_order_engine<_Eng, _Kp>& __x);
3355 _LIBCPP_INLINE_VISIBILITY
3358 for (size_t __i = 0; __i < __k; ++__i)
3363 _LIBCPP_INLINE_VISIBILITY
3364 result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
3365 _LIBCPP_INLINE_VISIBILITY
3366 result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
3368 _LIBCPP_INLINE_VISIBILITY
3369 result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
3370 _LIBCPP_INLINE_VISIBILITY
3371 result_type __eval2(true_type) {return __evalf<__k, 0>();}
3373 template <uint64_t _Np, uint64_t _Dp>
3374 _LIBCPP_INLINE_VISIBILITY
3377 (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
3380 __eval(__uratio<_Np, _Dp>)
3381 {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
3383 template <uint64_t _Np, uint64_t _Dp>
3384 _LIBCPP_INLINE_VISIBILITY
3387 __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
3390 __eval(__uratio<_Np, _Dp>)
3392 const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (_Y_ - _Min)
3393 / __uratio<_Np, _Dp>::den);
3399 template <uint64_t __n, uint64_t __d>
3400 _LIBCPP_INLINE_VISIBILITY
3401 result_type __evalf()
3403 const double _Fp = __d == 0 ?
3404 __n / (2. * 0x8000000000000000ull) :
3406 const size_t __j = static_cast<size_t>(_Fp * (_Y_ - _Min));
3413 template<class _Engine, size_t __k>
3414 _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
3416 template<class _Eng, size_t _Kp>
3419 const shuffle_order_engine<_Eng, _Kp>& __x,
3420 const shuffle_order_engine<_Eng, _Kp>& __y)
3422 return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
3423 __x.__e_ == __y.__e_;
3426 template<class _Eng, size_t _Kp>
3427 inline _LIBCPP_INLINE_VISIBILITY
3430 const shuffle_order_engine<_Eng, _Kp>& __x,
3431 const shuffle_order_engine<_Eng, _Kp>& __y)
3433 return !(__x == __y);
3436 template <class _CharT, class _Traits,
3437 class _Eng, size_t _Kp>
3438 basic_ostream<_CharT, _Traits>&
3439 operator<<(basic_ostream<_CharT, _Traits>& __os,
3440 const shuffle_order_engine<_Eng, _Kp>& __x)
3442 __save_flags<_CharT, _Traits> __lx(__os);
3443 __os.flags(ios_base::dec | ios_base::left);
3444 _CharT __sp = __os.widen(' ');
3446 __os << __x.__e_ << __sp << __x._V_[0];
3447 for (size_t __i = 1; __i < _Kp; ++__i)
3448 __os << __sp << __x._V_[__i];
3449 return __os << __sp << __x._Y_;
3452 template <class _CharT, class _Traits,
3453 class _Eng, size_t _Kp>
3454 basic_istream<_CharT, _Traits>&
3455 operator>>(basic_istream<_CharT, _Traits>& __is,
3456 shuffle_order_engine<_Eng, _Kp>& __x)
3458 typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
3459 __save_flags<_CharT, _Traits> __lx(__is);
3460 __is.flags(ios_base::dec | ios_base::skipws);
3462 result_type _Vp[_Kp+1];
3464 for (size_t __i = 0; __i < _Kp+1; ++__i)
3469 for (size_t __i = 0; __i < _Kp; ++__i)
3470 __x._V_[__i] = _Vp[__i];
3476 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
3480 class _LIBCPP_TYPE_VIS random_device
3482 #ifdef _LIBCPP_USING_DEV_RANDOM
3484 #endif // defined(_LIBCPP_USING_DEV_RANDOM)
3487 typedef unsigned result_type;
3489 // generator characteristics
3490 static _LIBCPP_CONSTEXPR const result_type _Min = 0;
3491 static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
3493 _LIBCPP_INLINE_VISIBILITY
3494 static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
3495 _LIBCPP_INLINE_VISIBILITY
3496 static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
3499 explicit random_device(const string& __token = "/dev/urandom");
3502 // generating functions
3503 result_type operator()();
3505 // property functions
3506 double entropy() const _NOEXCEPT;
3509 // no copy functions
3510 random_device(const random_device&); // = delete;
3511 random_device& operator=(const random_device&); // = delete;
3516 class _LIBCPP_TEMPLATE_VIS seed_seq
3520 typedef uint32_t result_type;
3523 vector<result_type> __v_;
3525 template<class _InputIterator>
3526 void init(_InputIterator __first, _InputIterator __last);
3529 _LIBCPP_INLINE_VISIBILITY
3530 seed_seq() _NOEXCEPT {}
3531 #ifndef _LIBCPP_CXX03_LANG
3533 _LIBCPP_INLINE_VISIBILITY
3534 seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
3535 #endif // _LIBCPP_CXX03_LANG
3537 template<class _InputIterator>
3538 _LIBCPP_INLINE_VISIBILITY
3539 seed_seq(_InputIterator __first, _InputIterator __last)
3540 {init(__first, __last);}
3542 // generating functions
3543 template<class _RandomAccessIterator>
3544 void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
3546 // property functions
3547 _LIBCPP_INLINE_VISIBILITY
3548 size_t size() const _NOEXCEPT {return __v_.size();}
3549 template<class _OutputIterator>
3550 _LIBCPP_INLINE_VISIBILITY
3551 void param(_OutputIterator __dest) const
3552 {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
3555 // no copy functions
3556 seed_seq(const seed_seq&); // = delete;
3557 void operator=(const seed_seq&); // = delete;
3559 _LIBCPP_INLINE_VISIBILITY
3560 static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
3563 template<class _InputIterator>
3565 seed_seq::init(_InputIterator __first, _InputIterator __last)
3567 for (_InputIterator __s = __first; __s != __last; ++__s)
3568 __v_.push_back(*__s & 0xFFFFFFFF);
3571 template<class _RandomAccessIterator>
3573 seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
3575 if (__first != __last)
3577 _VSTD::fill(__first, __last, 0x8b8b8b8b);
3578 const size_t __n = static_cast<size_t>(__last - __first);
3579 const size_t __s = __v_.size();
3580 const size_t __t = (__n >= 623) ? 11
3585 const size_t __p = (__n - __t) / 2;
3586 const size_t __q = __p + __t;
3587 const size_t __m = _VSTD::max(__s + 1, __n);
3590 result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
3591 ^ __first[__n - 1]);
3592 __first[__p] += __r;
3594 __first[__q] += __r;
3597 for (size_t __k = 1; __k <= __s; ++__k)
3599 const size_t __kmodn = __k % __n;
3600 const size_t __kpmodn = (__k + __p) % __n;
3601 result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
3602 ^ __first[(__k - 1) % __n]);
3603 __first[__kpmodn] += __r;
3604 __r += __kmodn + __v_[__k-1];
3605 __first[(__k + __q) % __n] += __r;
3606 __first[__kmodn] = __r;
3608 for (size_t __k = __s + 1; __k < __m; ++__k)
3610 const size_t __kmodn = __k % __n;
3611 const size_t __kpmodn = (__k + __p) % __n;
3612 result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
3613 ^ __first[(__k - 1) % __n]);
3614 __first[__kpmodn] += __r;
3616 __first[(__k + __q) % __n] += __r;
3617 __first[__kmodn] = __r;
3619 for (size_t __k = __m; __k < __m + __n; ++__k)
3621 const size_t __kmodn = __k % __n;
3622 const size_t __kpmodn = (__k + __p) % __n;
3623 result_type __r = 1566083941 * _Tp(__first[__kmodn] +
3625 __first[(__k - 1) % __n]);
3626 __first[__kpmodn] ^= __r;
3628 __first[(__k + __q) % __n] ^= __r;
3629 __first[__kmodn] = __r;
3634 // generate_canonical
3636 template<class _RealType, size_t __bits, class _URNG>
3638 generate_canonical(_URNG& __g)
3640 const size_t _Dt = numeric_limits<_RealType>::digits;
3641 const size_t __b = _Dt < __bits ? _Dt : __bits;
3642 #ifdef _LIBCPP_CXX03_LANG
3643 const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
3645 const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
3647 const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
3648 const _RealType _Rp = _URNG::max() - _URNG::min() + _RealType(1);
3649 _RealType __base = _Rp;
3650 _RealType _Sp = __g() - _URNG::min();
3651 for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
3652 _Sp += (__g() - _URNG::min()) * __base;
3653 return _Sp / __base;
3656 // uniform_int_distribution
3660 template <class _CharT, class _Traits, class _IT>
3661 basic_ostream<_CharT, _Traits>&
3662 operator<<(basic_ostream<_CharT, _Traits>& __os,
3663 const uniform_int_distribution<_IT>& __x)
3665 __save_flags<_CharT, _Traits> __lx(__os);
3666 __os.flags(ios_base::dec | ios_base::left);
3667 _CharT __sp = __os.widen(' ');
3669 return __os << __x.a() << __sp << __x.b();
3672 template <class _CharT, class _Traits, class _IT>
3673 basic_istream<_CharT, _Traits>&
3674 operator>>(basic_istream<_CharT, _Traits>& __is,
3675 uniform_int_distribution<_IT>& __x)
3677 typedef uniform_int_distribution<_IT> _Eng;
3678 typedef typename _Eng::result_type result_type;
3679 typedef typename _Eng::param_type param_type;
3680 __save_flags<_CharT, _Traits> __lx(__is);
3681 __is.flags(ios_base::dec | ios_base::skipws);
3686 __x.param(param_type(__a, __b));
3690 // uniform_real_distribution
3692 template<class _RealType = double>
3693 class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
3697 typedef _RealType result_type;
3699 class _LIBCPP_TEMPLATE_VIS param_type
3704 typedef uniform_real_distribution distribution_type;
3706 _LIBCPP_INLINE_VISIBILITY
3707 explicit param_type(result_type __a = 0,
3708 result_type __b = 1)
3709 : __a_(__a), __b_(__b) {}
3711 _LIBCPP_INLINE_VISIBILITY
3712 result_type a() const {return __a_;}
3713 _LIBCPP_INLINE_VISIBILITY
3714 result_type b() const {return __b_;}
3716 friend _LIBCPP_INLINE_VISIBILITY
3717 bool operator==(const param_type& __x, const param_type& __y)
3718 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
3719 friend _LIBCPP_INLINE_VISIBILITY
3720 bool operator!=(const param_type& __x, const param_type& __y)
3721 {return !(__x == __y);}
3728 // constructors and reset functions
3729 _LIBCPP_INLINE_VISIBILITY
3730 explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
3731 : __p_(param_type(__a, __b)) {}
3732 _LIBCPP_INLINE_VISIBILITY
3733 explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
3734 _LIBCPP_INLINE_VISIBILITY
3737 // generating functions
3738 template<class _URNG>
3739 _LIBCPP_INLINE_VISIBILITY
3740 result_type operator()(_URNG& __g)
3741 {return (*this)(__g, __p_);}
3742 template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
3744 // property functions
3745 _LIBCPP_INLINE_VISIBILITY
3746 result_type a() const {return __p_.a();}
3747 _LIBCPP_INLINE_VISIBILITY
3748 result_type b() const {return __p_.b();}
3750 _LIBCPP_INLINE_VISIBILITY
3751 param_type param() const {return __p_;}
3752 _LIBCPP_INLINE_VISIBILITY
3753 void param(const param_type& __p) {__p_ = __p;}
3755 _LIBCPP_INLINE_VISIBILITY
3756 result_type min() const {return a();}
3757 _LIBCPP_INLINE_VISIBILITY
3758 result_type max() const {return b();}
3760 friend _LIBCPP_INLINE_VISIBILITY
3761 bool operator==(const uniform_real_distribution& __x,
3762 const uniform_real_distribution& __y)
3763 {return __x.__p_ == __y.__p_;}
3764 friend _LIBCPP_INLINE_VISIBILITY
3765 bool operator!=(const uniform_real_distribution& __x,
3766 const uniform_real_distribution& __y)
3767 {return !(__x == __y);}
3770 template<class _RealType>
3771 template<class _URNG>
3773 typename uniform_real_distribution<_RealType>::result_type
3774 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
3776 return (__p.b() - __p.a())
3777 * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
3781 template <class _CharT, class _Traits, class _RT>
3782 basic_ostream<_CharT, _Traits>&
3783 operator<<(basic_ostream<_CharT, _Traits>& __os,
3784 const uniform_real_distribution<_RT>& __x)
3786 __save_flags<_CharT, _Traits> __lx(__os);
3787 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
3788 ios_base::scientific);
3789 _CharT __sp = __os.widen(' ');
3791 return __os << __x.a() << __sp << __x.b();
3794 template <class _CharT, class _Traits, class _RT>
3795 basic_istream<_CharT, _Traits>&
3796 operator>>(basic_istream<_CharT, _Traits>& __is,
3797 uniform_real_distribution<_RT>& __x)
3799 typedef uniform_real_distribution<_RT> _Eng;
3800 typedef typename _Eng::result_type result_type;
3801 typedef typename _Eng::param_type param_type;
3802 __save_flags<_CharT, _Traits> __lx(__is);
3803 __is.flags(ios_base::dec | ios_base::skipws);
3808 __x.param(param_type(__a, __b));
3812 // bernoulli_distribution
3814 class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
3818 typedef bool result_type;
3820 class _LIBCPP_TEMPLATE_VIS param_type
3824 typedef bernoulli_distribution distribution_type;
3826 _LIBCPP_INLINE_VISIBILITY
3827 explicit param_type(double __p = 0.5) : __p_(__p) {}
3829 _LIBCPP_INLINE_VISIBILITY
3830 double p() const {return __p_;}
3832 friend _LIBCPP_INLINE_VISIBILITY
3833 bool operator==(const param_type& __x, const param_type& __y)
3834 {return __x.__p_ == __y.__p_;}
3835 friend _LIBCPP_INLINE_VISIBILITY
3836 bool operator!=(const param_type& __x, const param_type& __y)
3837 {return !(__x == __y);}
3844 // constructors and reset functions
3845 _LIBCPP_INLINE_VISIBILITY
3846 explicit bernoulli_distribution(double __p = 0.5)
3847 : __p_(param_type(__p)) {}
3848 _LIBCPP_INLINE_VISIBILITY
3849 explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
3850 _LIBCPP_INLINE_VISIBILITY
3853 // generating functions
3854 template<class _URNG>
3855 _LIBCPP_INLINE_VISIBILITY
3856 result_type operator()(_URNG& __g)
3857 {return (*this)(__g, __p_);}
3858 template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
3860 // property functions
3861 _LIBCPP_INLINE_VISIBILITY
3862 double p() const {return __p_.p();}
3864 _LIBCPP_INLINE_VISIBILITY
3865 param_type param() const {return __p_;}
3866 _LIBCPP_INLINE_VISIBILITY
3867 void param(const param_type& __p) {__p_ = __p;}
3869 _LIBCPP_INLINE_VISIBILITY
3870 result_type min() const {return false;}
3871 _LIBCPP_INLINE_VISIBILITY
3872 result_type max() const {return true;}
3874 friend _LIBCPP_INLINE_VISIBILITY
3875 bool operator==(const bernoulli_distribution& __x,
3876 const bernoulli_distribution& __y)
3877 {return __x.__p_ == __y.__p_;}
3878 friend _LIBCPP_INLINE_VISIBILITY
3879 bool operator!=(const bernoulli_distribution& __x,
3880 const bernoulli_distribution& __y)
3881 {return !(__x == __y);}
3884 template<class _URNG>
3886 bernoulli_distribution::result_type
3887 bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
3889 uniform_real_distribution<double> __gen;
3890 return __gen(__g) < __p.p();
3893 template <class _CharT, class _Traits>
3894 basic_ostream<_CharT, _Traits>&
3895 operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
3897 __save_flags<_CharT, _Traits> __lx(__os);
3898 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
3899 ios_base::scientific);
3900 _CharT __sp = __os.widen(' ');
3902 return __os << __x.p();
3905 template <class _CharT, class _Traits>
3906 basic_istream<_CharT, _Traits>&
3907 operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
3909 typedef bernoulli_distribution _Eng;
3910 typedef typename _Eng::param_type param_type;
3911 __save_flags<_CharT, _Traits> __lx(__is);
3912 __is.flags(ios_base::dec | ios_base::skipws);
3916 __x.param(param_type(__p));
3920 // binomial_distribution
3922 template<class _IntType = int>
3923 class _LIBCPP_TEMPLATE_VIS binomial_distribution
3927 typedef _IntType result_type;
3929 class _LIBCPP_TEMPLATE_VIS param_type
3934 double __odds_ratio_;
3937 typedef binomial_distribution distribution_type;
3939 explicit param_type(result_type __t = 1, double __p = 0.5);
3941 _LIBCPP_INLINE_VISIBILITY
3942 result_type t() const {return __t_;}
3943 _LIBCPP_INLINE_VISIBILITY
3944 double p() const {return __p_;}
3946 friend _LIBCPP_INLINE_VISIBILITY
3947 bool operator==(const param_type& __x, const param_type& __y)
3948 {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
3949 friend _LIBCPP_INLINE_VISIBILITY
3950 bool operator!=(const param_type& __x, const param_type& __y)
3951 {return !(__x == __y);}
3953 friend class binomial_distribution;
3960 // constructors and reset functions
3961 _LIBCPP_INLINE_VISIBILITY
3962 explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
3963 : __p_(param_type(__t, __p)) {}
3964 _LIBCPP_INLINE_VISIBILITY
3965 explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
3966 _LIBCPP_INLINE_VISIBILITY
3969 // generating functions
3970 template<class _URNG>
3971 _LIBCPP_INLINE_VISIBILITY
3972 result_type operator()(_URNG& __g)
3973 {return (*this)(__g, __p_);}
3974 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
3976 // property functions
3977 _LIBCPP_INLINE_VISIBILITY
3978 result_type t() const {return __p_.t();}
3979 _LIBCPP_INLINE_VISIBILITY
3980 double p() const {return __p_.p();}
3982 _LIBCPP_INLINE_VISIBILITY
3983 param_type param() const {return __p_;}
3984 _LIBCPP_INLINE_VISIBILITY
3985 void param(const param_type& __p) {__p_ = __p;}
3987 _LIBCPP_INLINE_VISIBILITY
3988 result_type min() const {return 0;}
3989 _LIBCPP_INLINE_VISIBILITY
3990 result_type max() const {return t();}
3992 friend _LIBCPP_INLINE_VISIBILITY
3993 bool operator==(const binomial_distribution& __x,
3994 const binomial_distribution& __y)
3995 {return __x.__p_ == __y.__p_;}
3996 friend _LIBCPP_INLINE_VISIBILITY
3997 bool operator!=(const binomial_distribution& __x,
3998 const binomial_distribution& __y)
3999 {return !(__x == __y);}
4002 #ifndef _LIBCPP_MSVCRT
4003 extern "C" double lgamma_r(double, int *);
4006 inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
4007 #if defined(_LIBCPP_MSVCRT)
4011 return lgamma_r(__d, &__sign);
4015 template<class _IntType>
4016 binomial_distribution<_IntType>::param_type::param_type(const result_type __t, const double __p)
4017 : __t_(__t), __p_(__p)
4019 if (0 < __p_ && __p_ < 1)
4021 __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
4022 __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) -
4023 __libcpp_lgamma(__r0_ + 1.) -
4024 __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
4025 (__t_ - __r0_) * _VSTD::log(1 - __p_));
4026 __odds_ratio_ = __p_ / (1 - __p_);
4030 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
4031 // variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
4032 template<class _IntType>
4033 template<class _URNG>
4035 binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
4037 if (__pr.__t_ == 0 || __pr.__p_ == 0)
4041 uniform_real_distribution<double> __gen;
4042 double __u = __gen(__g) - __pr.__pr_;
4045 double __pu = __pr.__pr_;
4047 result_type __ru = __pr.__r0_;
4048 result_type __rd = __ru;
4053 __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
4061 if (__ru <= __pr.__t_)
4063 __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
4071 template <class _CharT, class _Traits, class _IntType>
4072 basic_ostream<_CharT, _Traits>&
4073 operator<<(basic_ostream<_CharT, _Traits>& __os,
4074 const binomial_distribution<_IntType>& __x)
4076 __save_flags<_CharT, _Traits> __lx(__os);
4077 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4078 ios_base::scientific);
4079 _CharT __sp = __os.widen(' ');
4081 return __os << __x.t() << __sp << __x.p();
4084 template <class _CharT, class _Traits, class _IntType>
4085 basic_istream<_CharT, _Traits>&
4086 operator>>(basic_istream<_CharT, _Traits>& __is,
4087 binomial_distribution<_IntType>& __x)
4089 typedef binomial_distribution<_IntType> _Eng;
4090 typedef typename _Eng::result_type result_type;
4091 typedef typename _Eng::param_type param_type;
4092 __save_flags<_CharT, _Traits> __lx(__is);
4093 __is.flags(ios_base::dec | ios_base::skipws);
4098 __x.param(param_type(__t, __p));
4102 // exponential_distribution
4104 template<class _RealType = double>
4105 class _LIBCPP_TEMPLATE_VIS exponential_distribution
4109 typedef _RealType result_type;
4111 class _LIBCPP_TEMPLATE_VIS param_type
4113 result_type __lambda_;
4115 typedef exponential_distribution distribution_type;
4117 _LIBCPP_INLINE_VISIBILITY
4118 explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
4120 _LIBCPP_INLINE_VISIBILITY
4121 result_type lambda() const {return __lambda_;}
4123 friend _LIBCPP_INLINE_VISIBILITY
4124 bool operator==(const param_type& __x, const param_type& __y)
4125 {return __x.__lambda_ == __y.__lambda_;}
4126 friend _LIBCPP_INLINE_VISIBILITY
4127 bool operator!=(const param_type& __x, const param_type& __y)
4128 {return !(__x == __y);}
4135 // constructors and reset functions
4136 _LIBCPP_INLINE_VISIBILITY
4137 explicit exponential_distribution(result_type __lambda = 1)
4138 : __p_(param_type(__lambda)) {}
4139 _LIBCPP_INLINE_VISIBILITY
4140 explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
4141 _LIBCPP_INLINE_VISIBILITY
4144 // generating functions
4145 template<class _URNG>
4146 _LIBCPP_INLINE_VISIBILITY
4147 result_type operator()(_URNG& __g)
4148 {return (*this)(__g, __p_);}
4149 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
4151 // property functions
4152 _LIBCPP_INLINE_VISIBILITY
4153 result_type lambda() const {return __p_.lambda();}
4155 _LIBCPP_INLINE_VISIBILITY
4156 param_type param() const {return __p_;}
4157 _LIBCPP_INLINE_VISIBILITY
4158 void param(const param_type& __p) {__p_ = __p;}
4160 _LIBCPP_INLINE_VISIBILITY
4161 result_type min() const {return 0;}
4162 _LIBCPP_INLINE_VISIBILITY
4163 result_type max() const {return numeric_limits<result_type>::infinity();}
4165 friend _LIBCPP_INLINE_VISIBILITY
4166 bool operator==(const exponential_distribution& __x,
4167 const exponential_distribution& __y)
4168 {return __x.__p_ == __y.__p_;}
4169 friend _LIBCPP_INLINE_VISIBILITY
4170 bool operator!=(const exponential_distribution& __x,
4171 const exponential_distribution& __y)
4172 {return !(__x == __y);}
4175 template <class _RealType>
4176 template<class _URNG>
4178 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
4183 _VSTD::generate_canonical<result_type,
4184 numeric_limits<result_type>::digits>(__g)
4189 template <class _CharT, class _Traits, class _RealType>
4190 basic_ostream<_CharT, _Traits>&
4191 operator<<(basic_ostream<_CharT, _Traits>& __os,
4192 const exponential_distribution<_RealType>& __x)
4194 __save_flags<_CharT, _Traits> __lx(__os);
4195 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4196 ios_base::scientific);
4197 return __os << __x.lambda();
4200 template <class _CharT, class _Traits, class _RealType>
4201 basic_istream<_CharT, _Traits>&
4202 operator>>(basic_istream<_CharT, _Traits>& __is,
4203 exponential_distribution<_RealType>& __x)
4205 typedef exponential_distribution<_RealType> _Eng;
4206 typedef typename _Eng::result_type result_type;
4207 typedef typename _Eng::param_type param_type;
4208 __save_flags<_CharT, _Traits> __lx(__is);
4209 __is.flags(ios_base::dec | ios_base::skipws);
4210 result_type __lambda;
4213 __x.param(param_type(__lambda));
4217 // normal_distribution
4219 template<class _RealType = double>
4220 class _LIBCPP_TEMPLATE_VIS normal_distribution
4224 typedef _RealType result_type;
4226 class _LIBCPP_TEMPLATE_VIS param_type
4228 result_type __mean_;
4229 result_type __stddev_;
4231 typedef normal_distribution distribution_type;
4233 _LIBCPP_INLINE_VISIBILITY
4234 explicit param_type(result_type __mean = 0, result_type __stddev = 1)
4235 : __mean_(__mean), __stddev_(__stddev) {}
4237 _LIBCPP_INLINE_VISIBILITY
4238 result_type mean() const {return __mean_;}
4239 _LIBCPP_INLINE_VISIBILITY
4240 result_type stddev() const {return __stddev_;}
4242 friend _LIBCPP_INLINE_VISIBILITY
4243 bool operator==(const param_type& __x, const param_type& __y)
4244 {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
4245 friend _LIBCPP_INLINE_VISIBILITY
4246 bool operator!=(const param_type& __x, const param_type& __y)
4247 {return !(__x == __y);}
4256 // constructors and reset functions
4257 _LIBCPP_INLINE_VISIBILITY
4258 explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
4259 : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
4260 _LIBCPP_INLINE_VISIBILITY
4261 explicit normal_distribution(const param_type& __p)
4262 : __p_(__p), _V_hot_(false) {}
4263 _LIBCPP_INLINE_VISIBILITY
4264 void reset() {_V_hot_ = false;}
4266 // generating functions
4267 template<class _URNG>
4268 _LIBCPP_INLINE_VISIBILITY
4269 result_type operator()(_URNG& __g)
4270 {return (*this)(__g, __p_);}
4271 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
4273 // property functions
4274 _LIBCPP_INLINE_VISIBILITY
4275 result_type mean() const {return __p_.mean();}
4276 _LIBCPP_INLINE_VISIBILITY
4277 result_type stddev() const {return __p_.stddev();}
4279 _LIBCPP_INLINE_VISIBILITY
4280 param_type param() const {return __p_;}
4281 _LIBCPP_INLINE_VISIBILITY
4282 void param(const param_type& __p) {__p_ = __p;}
4284 _LIBCPP_INLINE_VISIBILITY
4285 result_type min() const {return -numeric_limits<result_type>::infinity();}
4286 _LIBCPP_INLINE_VISIBILITY
4287 result_type max() const {return numeric_limits<result_type>::infinity();}
4289 friend _LIBCPP_INLINE_VISIBILITY
4290 bool operator==(const normal_distribution& __x,
4291 const normal_distribution& __y)
4292 {return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ &&
4293 (!__x._V_hot_ || __x._V_ == __y._V_);}
4294 friend _LIBCPP_INLINE_VISIBILITY
4295 bool operator!=(const normal_distribution& __x,
4296 const normal_distribution& __y)
4297 {return !(__x == __y);}
4299 template <class _CharT, class _Traits, class _RT>
4301 basic_ostream<_CharT, _Traits>&
4302 operator<<(basic_ostream<_CharT, _Traits>& __os,
4303 const normal_distribution<_RT>& __x);
4305 template <class _CharT, class _Traits, class _RT>
4307 basic_istream<_CharT, _Traits>&
4308 operator>>(basic_istream<_CharT, _Traits>& __is,
4309 normal_distribution<_RT>& __x);
4312 template <class _RealType>
4313 template<class _URNG>
4315 normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
4325 uniform_real_distribution<result_type> _Uni(-1, 1);
4333 __s = __u * __u + __v * __v;
4334 } while (__s > 1 || __s == 0);
4335 result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
4340 return _Up * __p.stddev() + __p.mean();
4343 template <class _CharT, class _Traits, class _RT>
4344 basic_ostream<_CharT, _Traits>&
4345 operator<<(basic_ostream<_CharT, _Traits>& __os,
4346 const normal_distribution<_RT>& __x)
4348 __save_flags<_CharT, _Traits> __lx(__os);
4349 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4350 ios_base::scientific);
4351 _CharT __sp = __os.widen(' ');
4353 __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
4355 __os << __sp << __x._V_;
4359 template <class _CharT, class _Traits, class _RT>
4360 basic_istream<_CharT, _Traits>&
4361 operator>>(basic_istream<_CharT, _Traits>& __is,
4362 normal_distribution<_RT>& __x)
4364 typedef normal_distribution<_RT> _Eng;
4365 typedef typename _Eng::result_type result_type;
4366 typedef typename _Eng::param_type param_type;
4367 __save_flags<_CharT, _Traits> __lx(__is);
4368 __is.flags(ios_base::dec | ios_base::skipws);
4370 result_type __stddev;
4371 result_type _Vp = 0;
4372 bool _V_hot = false;
4373 __is >> __mean >> __stddev >> _V_hot;
4378 __x.param(param_type(__mean, __stddev));
4379 __x._V_hot_ = _V_hot;
4385 // lognormal_distribution
4387 template<class _RealType = double>
4388 class _LIBCPP_TEMPLATE_VIS lognormal_distribution
4392 typedef _RealType result_type;
4394 class _LIBCPP_TEMPLATE_VIS param_type
4396 normal_distribution<result_type> __nd_;
4398 typedef lognormal_distribution distribution_type;
4400 _LIBCPP_INLINE_VISIBILITY
4401 explicit param_type(result_type __m = 0, result_type __s = 1)
4402 : __nd_(__m, __s) {}
4404 _LIBCPP_INLINE_VISIBILITY
4405 result_type m() const {return __nd_.mean();}
4406 _LIBCPP_INLINE_VISIBILITY
4407 result_type s() const {return __nd_.stddev();}
4409 friend _LIBCPP_INLINE_VISIBILITY
4410 bool operator==(const param_type& __x, const param_type& __y)
4411 {return __x.__nd_ == __y.__nd_;}
4412 friend _LIBCPP_INLINE_VISIBILITY
4413 bool operator!=(const param_type& __x, const param_type& __y)
4414 {return !(__x == __y);}
4415 friend class lognormal_distribution;
4417 template <class _CharT, class _Traits, class _RT>
4419 basic_ostream<_CharT, _Traits>&
4420 operator<<(basic_ostream<_CharT, _Traits>& __os,
4421 const lognormal_distribution<_RT>& __x);
4423 template <class _CharT, class _Traits, class _RT>
4425 basic_istream<_CharT, _Traits>&
4426 operator>>(basic_istream<_CharT, _Traits>& __is,
4427 lognormal_distribution<_RT>& __x);
4434 // constructor and reset functions
4435 _LIBCPP_INLINE_VISIBILITY
4436 explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
4437 : __p_(param_type(__m, __s)) {}
4438 _LIBCPP_INLINE_VISIBILITY
4439 explicit lognormal_distribution(const param_type& __p)
4441 _LIBCPP_INLINE_VISIBILITY
4442 void reset() {__p_.__nd_.reset();}
4444 // generating functions
4445 template<class _URNG>
4446 _LIBCPP_INLINE_VISIBILITY
4447 result_type operator()(_URNG& __g)
4448 {return (*this)(__g, __p_);}
4449 template<class _URNG>
4450 _LIBCPP_INLINE_VISIBILITY
4451 result_type operator()(_URNG& __g, const param_type& __p)
4452 {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
4454 // property functions
4455 _LIBCPP_INLINE_VISIBILITY
4456 result_type m() const {return __p_.m();}
4457 _LIBCPP_INLINE_VISIBILITY
4458 result_type s() const {return __p_.s();}
4460 _LIBCPP_INLINE_VISIBILITY
4461 param_type param() const {return __p_;}
4462 _LIBCPP_INLINE_VISIBILITY
4463 void param(const param_type& __p) {__p_ = __p;}
4465 _LIBCPP_INLINE_VISIBILITY
4466 result_type min() const {return 0;}
4467 _LIBCPP_INLINE_VISIBILITY
4468 result_type max() const {return numeric_limits<result_type>::infinity();}
4470 friend _LIBCPP_INLINE_VISIBILITY
4471 bool operator==(const lognormal_distribution& __x,
4472 const lognormal_distribution& __y)
4473 {return __x.__p_ == __y.__p_;}
4474 friend _LIBCPP_INLINE_VISIBILITY
4475 bool operator!=(const lognormal_distribution& __x,
4476 const lognormal_distribution& __y)
4477 {return !(__x == __y);}
4479 template <class _CharT, class _Traits, class _RT>
4481 basic_ostream<_CharT, _Traits>&
4482 operator<<(basic_ostream<_CharT, _Traits>& __os,
4483 const lognormal_distribution<_RT>& __x);
4485 template <class _CharT, class _Traits, class _RT>
4487 basic_istream<_CharT, _Traits>&
4488 operator>>(basic_istream<_CharT, _Traits>& __is,
4489 lognormal_distribution<_RT>& __x);
4492 template <class _CharT, class _Traits, class _RT>
4493 inline _LIBCPP_INLINE_VISIBILITY
4494 basic_ostream<_CharT, _Traits>&
4495 operator<<(basic_ostream<_CharT, _Traits>& __os,
4496 const lognormal_distribution<_RT>& __x)
4498 return __os << __x.__p_.__nd_;
4501 template <class _CharT, class _Traits, class _RT>
4502 inline _LIBCPP_INLINE_VISIBILITY
4503 basic_istream<_CharT, _Traits>&
4504 operator>>(basic_istream<_CharT, _Traits>& __is,
4505 lognormal_distribution<_RT>& __x)
4507 return __is >> __x.__p_.__nd_;
4510 // poisson_distribution
4512 template<class _IntType = int>
4513 class _LIBCPP_TEMPLATE_VIS poisson_distribution
4517 typedef _IntType result_type;
4519 class _LIBCPP_TEMPLATE_VIS param_type
4533 typedef poisson_distribution distribution_type;
4535 explicit param_type(double __mean = 1.0);
4537 _LIBCPP_INLINE_VISIBILITY
4538 double mean() const {return __mean_;}
4540 friend _LIBCPP_INLINE_VISIBILITY
4541 bool operator==(const param_type& __x, const param_type& __y)
4542 {return __x.__mean_ == __y.__mean_;}
4543 friend _LIBCPP_INLINE_VISIBILITY
4544 bool operator!=(const param_type& __x, const param_type& __y)
4545 {return !(__x == __y);}
4547 friend class poisson_distribution;
4554 // constructors and reset functions
4555 _LIBCPP_INLINE_VISIBILITY
4556 explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
4557 _LIBCPP_INLINE_VISIBILITY
4558 explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
4559 _LIBCPP_INLINE_VISIBILITY
4562 // generating functions
4563 template<class _URNG>
4564 _LIBCPP_INLINE_VISIBILITY
4565 result_type operator()(_URNG& __g)
4566 {return (*this)(__g, __p_);}
4567 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
4569 // property functions
4570 _LIBCPP_INLINE_VISIBILITY
4571 double mean() const {return __p_.mean();}
4573 _LIBCPP_INLINE_VISIBILITY
4574 param_type param() const {return __p_;}
4575 _LIBCPP_INLINE_VISIBILITY
4576 void param(const param_type& __p) {__p_ = __p;}
4578 _LIBCPP_INLINE_VISIBILITY
4579 result_type min() const {return 0;}
4580 _LIBCPP_INLINE_VISIBILITY
4581 result_type max() const {return numeric_limits<result_type>::max();}
4583 friend _LIBCPP_INLINE_VISIBILITY
4584 bool operator==(const poisson_distribution& __x,
4585 const poisson_distribution& __y)
4586 {return __x.__p_ == __y.__p_;}
4587 friend _LIBCPP_INLINE_VISIBILITY
4588 bool operator!=(const poisson_distribution& __x,
4589 const poisson_distribution& __y)
4590 {return !(__x == __y);}
4593 template<class _IntType>
4594 poisson_distribution<_IntType>::param_type::param_type(double __mean)
4601 __l_ = _VSTD::exp(-__mean_);
4611 __s_ = _VSTD::sqrt(__mean_);
4612 __d_ = 6 * __mean_ * __mean_;
4613 __l_ = static_cast<result_type>(__mean_ - 1.1484);
4614 __omega_ = .3989423 / __s_;
4615 double __b1_ = .4166667E-1 / __mean_;
4616 double __b2_ = .3 * __b1_ * __b1_;
4617 __c3_ = .1428571 * __b1_ * __b2_;
4618 __c2_ = __b2_ - 15. * __c3_;
4619 __c1_ = __b1_ - 6. * __b2_ + 45. * __c3_;
4620 __c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_;
4621 __c_ = .1069 / __mean_;
4625 template <class _IntType>
4626 template<class _URNG>
4628 poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
4631 uniform_real_distribution<double> __urd;
4632 if (__pr.__mean_ < 10)
4635 for (double __p = __urd(__urng); __p > __pr.__l_; ++__x)
4636 __p *= __urd(__urng);
4641 double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
4645 __x = static_cast<result_type>(__g);
4646 if (__x >= __pr.__l_)
4648 __difmuk = __pr.__mean_ - __x;
4649 __u = __urd(__urng);
4650 if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
4653 exponential_distribution<double> __edist;
4654 for (bool __using_exp_dist = false; true; __using_exp_dist = true)
4657 if (__using_exp_dist || __g < 0)
4662 __e = __edist(__urng);
4663 __u = __urd(__urng);
4665 __t = 1.8 + (__u < 0 ? -__e : __e);
4666 } while (__t <= -.6744);
4667 __x = __pr.__mean_ + __pr.__s_ * __t;
4668 __difmuk = __pr.__mean_ - __x;
4669 __using_exp_dist = true;
4675 const result_type __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
4677 __px = -__pr.__mean_;
4678 __py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
4682 double __del = .8333333E-1 / __x;
4683 __del -= 4.8 * __del * __del * __del;
4684 double __v = __difmuk / __x;
4685 if (_VSTD::abs(__v) > 0.25)
4686 __px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
4688 __px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
4689 __v + .1421878) * __v + -.1661269) * __v + .2000118) *
4690 __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
4691 __py = .3989423 / _VSTD::sqrt(__x);
4693 double __r = (0.5 - __difmuk) / __pr.__s_;
4694 double __r2 = __r * __r;
4695 double __fx = -0.5 * __r2;
4696 double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
4697 __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
4698 if (__using_exp_dist)
4700 if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
4701 __fy * _VSTD::exp(__fx + __e))
4706 if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
4714 template <class _CharT, class _Traits, class _IntType>
4715 basic_ostream<_CharT, _Traits>&
4716 operator<<(basic_ostream<_CharT, _Traits>& __os,
4717 const poisson_distribution<_IntType>& __x)
4719 __save_flags<_CharT, _Traits> __lx(__os);
4720 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4721 ios_base::scientific);
4722 return __os << __x.mean();
4725 template <class _CharT, class _Traits, class _IntType>
4726 basic_istream<_CharT, _Traits>&
4727 operator>>(basic_istream<_CharT, _Traits>& __is,
4728 poisson_distribution<_IntType>& __x)
4730 typedef poisson_distribution<_IntType> _Eng;
4731 typedef typename _Eng::param_type param_type;
4732 __save_flags<_CharT, _Traits> __lx(__is);
4733 __is.flags(ios_base::dec | ios_base::skipws);
4737 __x.param(param_type(__mean));
4741 // weibull_distribution
4743 template<class _RealType = double>
4744 class _LIBCPP_TEMPLATE_VIS weibull_distribution
4748 typedef _RealType result_type;
4750 class _LIBCPP_TEMPLATE_VIS param_type
4755 typedef weibull_distribution distribution_type;
4757 _LIBCPP_INLINE_VISIBILITY
4758 explicit param_type(result_type __a = 1, result_type __b = 1)
4759 : __a_(__a), __b_(__b) {}
4761 _LIBCPP_INLINE_VISIBILITY
4762 result_type a() const {return __a_;}
4763 _LIBCPP_INLINE_VISIBILITY
4764 result_type b() const {return __b_;}
4766 friend _LIBCPP_INLINE_VISIBILITY
4767 bool operator==(const param_type& __x, const param_type& __y)
4768 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
4769 friend _LIBCPP_INLINE_VISIBILITY
4770 bool operator!=(const param_type& __x, const param_type& __y)
4771 {return !(__x == __y);}
4778 // constructor and reset functions
4779 _LIBCPP_INLINE_VISIBILITY
4780 explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
4781 : __p_(param_type(__a, __b)) {}
4782 _LIBCPP_INLINE_VISIBILITY
4783 explicit weibull_distribution(const param_type& __p)
4785 _LIBCPP_INLINE_VISIBILITY
4788 // generating functions
4789 template<class _URNG>
4790 _LIBCPP_INLINE_VISIBILITY
4791 result_type operator()(_URNG& __g)
4792 {return (*this)(__g, __p_);}
4793 template<class _URNG>
4794 _LIBCPP_INLINE_VISIBILITY
4795 result_type operator()(_URNG& __g, const param_type& __p)
4797 _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
4799 // property functions
4800 _LIBCPP_INLINE_VISIBILITY
4801 result_type a() const {return __p_.a();}
4802 _LIBCPP_INLINE_VISIBILITY
4803 result_type b() const {return __p_.b();}
4805 _LIBCPP_INLINE_VISIBILITY
4806 param_type param() const {return __p_;}
4807 _LIBCPP_INLINE_VISIBILITY
4808 void param(const param_type& __p) {__p_ = __p;}
4810 _LIBCPP_INLINE_VISIBILITY
4811 result_type min() const {return 0;}
4812 _LIBCPP_INLINE_VISIBILITY
4813 result_type max() const {return numeric_limits<result_type>::infinity();}
4815 friend _LIBCPP_INLINE_VISIBILITY
4816 bool operator==(const weibull_distribution& __x,
4817 const weibull_distribution& __y)
4818 {return __x.__p_ == __y.__p_;}
4819 friend _LIBCPP_INLINE_VISIBILITY
4820 bool operator!=(const weibull_distribution& __x,
4821 const weibull_distribution& __y)
4822 {return !(__x == __y);}
4825 template <class _CharT, class _Traits, class _RT>
4826 basic_ostream<_CharT, _Traits>&
4827 operator<<(basic_ostream<_CharT, _Traits>& __os,
4828 const weibull_distribution<_RT>& __x)
4830 __save_flags<_CharT, _Traits> __lx(__os);
4831 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4832 ios_base::scientific);
4833 _CharT __sp = __os.widen(' ');
4835 __os << __x.a() << __sp << __x.b();
4839 template <class _CharT, class _Traits, class _RT>
4840 basic_istream<_CharT, _Traits>&
4841 operator>>(basic_istream<_CharT, _Traits>& __is,
4842 weibull_distribution<_RT>& __x)
4844 typedef weibull_distribution<_RT> _Eng;
4845 typedef typename _Eng::result_type result_type;
4846 typedef typename _Eng::param_type param_type;
4847 __save_flags<_CharT, _Traits> __lx(__is);
4848 __is.flags(ios_base::dec | ios_base::skipws);
4853 __x.param(param_type(__a, __b));
4857 template<class _RealType = double>
4858 class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
4862 typedef _RealType result_type;
4864 class _LIBCPP_TEMPLATE_VIS param_type
4869 typedef extreme_value_distribution distribution_type;
4871 _LIBCPP_INLINE_VISIBILITY
4872 explicit param_type(result_type __a = 0, result_type __b = 1)
4873 : __a_(__a), __b_(__b) {}
4875 _LIBCPP_INLINE_VISIBILITY
4876 result_type a() const {return __a_;}
4877 _LIBCPP_INLINE_VISIBILITY
4878 result_type b() const {return __b_;}
4880 friend _LIBCPP_INLINE_VISIBILITY
4881 bool operator==(const param_type& __x, const param_type& __y)
4882 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
4883 friend _LIBCPP_INLINE_VISIBILITY
4884 bool operator!=(const param_type& __x, const param_type& __y)
4885 {return !(__x == __y);}
4892 // constructor and reset functions
4893 _LIBCPP_INLINE_VISIBILITY
4894 explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
4895 : __p_(param_type(__a, __b)) {}
4896 _LIBCPP_INLINE_VISIBILITY
4897 explicit extreme_value_distribution(const param_type& __p)
4899 _LIBCPP_INLINE_VISIBILITY
4902 // generating functions
4903 template<class _URNG>
4904 _LIBCPP_INLINE_VISIBILITY
4905 result_type operator()(_URNG& __g)
4906 {return (*this)(__g, __p_);}
4907 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
4909 // property functions
4910 _LIBCPP_INLINE_VISIBILITY
4911 result_type a() const {return __p_.a();}
4912 _LIBCPP_INLINE_VISIBILITY
4913 result_type b() const {return __p_.b();}
4915 _LIBCPP_INLINE_VISIBILITY
4916 param_type param() const {return __p_;}
4917 _LIBCPP_INLINE_VISIBILITY
4918 void param(const param_type& __p) {__p_ = __p;}
4920 _LIBCPP_INLINE_VISIBILITY
4921 result_type min() const {return -numeric_limits<result_type>::infinity();}
4922 _LIBCPP_INLINE_VISIBILITY
4923 result_type max() const {return numeric_limits<result_type>::infinity();}
4925 friend _LIBCPP_INLINE_VISIBILITY
4926 bool operator==(const extreme_value_distribution& __x,
4927 const extreme_value_distribution& __y)
4928 {return __x.__p_ == __y.__p_;}
4929 friend _LIBCPP_INLINE_VISIBILITY
4930 bool operator!=(const extreme_value_distribution& __x,
4931 const extreme_value_distribution& __y)
4932 {return !(__x == __y);}
4935 template<class _RealType>
4936 template<class _URNG>
4938 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
4940 return __p.a() - __p.b() *
4941 _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
4944 template <class _CharT, class _Traits, class _RT>
4945 basic_ostream<_CharT, _Traits>&
4946 operator<<(basic_ostream<_CharT, _Traits>& __os,
4947 const extreme_value_distribution<_RT>& __x)
4949 __save_flags<_CharT, _Traits> __lx(__os);
4950 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
4951 ios_base::scientific);
4952 _CharT __sp = __os.widen(' ');
4954 __os << __x.a() << __sp << __x.b();
4958 template <class _CharT, class _Traits, class _RT>
4959 basic_istream<_CharT, _Traits>&
4960 operator>>(basic_istream<_CharT, _Traits>& __is,
4961 extreme_value_distribution<_RT>& __x)
4963 typedef extreme_value_distribution<_RT> _Eng;
4964 typedef typename _Eng::result_type result_type;
4965 typedef typename _Eng::param_type param_type;
4966 __save_flags<_CharT, _Traits> __lx(__is);
4967 __is.flags(ios_base::dec | ios_base::skipws);
4972 __x.param(param_type(__a, __b));
4976 // gamma_distribution
4978 template<class _RealType = double>
4979 class _LIBCPP_TEMPLATE_VIS gamma_distribution
4983 typedef _RealType result_type;
4985 class _LIBCPP_TEMPLATE_VIS param_type
4987 result_type __alpha_;
4988 result_type __beta_;
4990 typedef gamma_distribution distribution_type;
4992 _LIBCPP_INLINE_VISIBILITY
4993 explicit param_type(result_type __alpha = 1, result_type __beta = 1)
4994 : __alpha_(__alpha), __beta_(__beta) {}
4996 _LIBCPP_INLINE_VISIBILITY
4997 result_type alpha() const {return __alpha_;}
4998 _LIBCPP_INLINE_VISIBILITY
4999 result_type beta() const {return __beta_;}
5001 friend _LIBCPP_INLINE_VISIBILITY
5002 bool operator==(const param_type& __x, const param_type& __y)
5003 {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
5004 friend _LIBCPP_INLINE_VISIBILITY
5005 bool operator!=(const param_type& __x, const param_type& __y)
5006 {return !(__x == __y);}
5013 // constructors and reset functions
5014 _LIBCPP_INLINE_VISIBILITY
5015 explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
5016 : __p_(param_type(__alpha, __beta)) {}
5017 _LIBCPP_INLINE_VISIBILITY
5018 explicit gamma_distribution(const param_type& __p)
5020 _LIBCPP_INLINE_VISIBILITY
5023 // generating functions
5024 template<class _URNG>
5025 _LIBCPP_INLINE_VISIBILITY
5026 result_type operator()(_URNG& __g)
5027 {return (*this)(__g, __p_);}
5028 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
5030 // property functions
5031 _LIBCPP_INLINE_VISIBILITY
5032 result_type alpha() const {return __p_.alpha();}
5033 _LIBCPP_INLINE_VISIBILITY
5034 result_type beta() const {return __p_.beta();}
5036 _LIBCPP_INLINE_VISIBILITY
5037 param_type param() const {return __p_;}
5038 _LIBCPP_INLINE_VISIBILITY
5039 void param(const param_type& __p) {__p_ = __p;}
5041 _LIBCPP_INLINE_VISIBILITY
5042 result_type min() const {return 0;}
5043 _LIBCPP_INLINE_VISIBILITY
5044 result_type max() const {return numeric_limits<result_type>::infinity();}
5046 friend _LIBCPP_INLINE_VISIBILITY
5047 bool operator==(const gamma_distribution& __x,
5048 const gamma_distribution& __y)
5049 {return __x.__p_ == __y.__p_;}
5050 friend _LIBCPP_INLINE_VISIBILITY
5051 bool operator!=(const gamma_distribution& __x,
5052 const gamma_distribution& __y)
5053 {return !(__x == __y);}
5056 template <class _RealType>
5057 template<class _URNG>
5059 gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
5061 result_type __a = __p.alpha();
5062 uniform_real_distribution<result_type> __gen(0, 1);
5063 exponential_distribution<result_type> __egen;
5069 const result_type __b = __a - 1;
5070 const result_type __c = 3 * __a - result_type(0.75);
5073 const result_type __u = __gen(__g);
5074 const result_type __v = __gen(__g);
5075 const result_type __w = __u * (1 - __u);
5078 const result_type __y = _VSTD::sqrt(__c / __w) *
5079 (__u - result_type(0.5));
5083 const result_type __z = 64 * __w * __w * __w * __v * __v;
5084 if (__z <= 1 - 2 * __y * __y / __x)
5086 if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
5096 const result_type __u = __gen(__g);
5097 const result_type __es = __egen(__g);
5100 __x = _VSTD::pow(__u, 1 / __a);
5106 const result_type __e = -_VSTD::log((1-__u)/__a);
5107 __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
5108 if (__x <= __e + __es)
5113 return __x * __p.beta();
5116 template <class _CharT, class _Traits, class _RT>
5117 basic_ostream<_CharT, _Traits>&
5118 operator<<(basic_ostream<_CharT, _Traits>& __os,
5119 const gamma_distribution<_RT>& __x)
5121 __save_flags<_CharT, _Traits> __lx(__os);
5122 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5123 ios_base::scientific);
5124 _CharT __sp = __os.widen(' ');
5126 __os << __x.alpha() << __sp << __x.beta();
5130 template <class _CharT, class _Traits, class _RT>
5131 basic_istream<_CharT, _Traits>&
5132 operator>>(basic_istream<_CharT, _Traits>& __is,
5133 gamma_distribution<_RT>& __x)
5135 typedef gamma_distribution<_RT> _Eng;
5136 typedef typename _Eng::result_type result_type;
5137 typedef typename _Eng::param_type param_type;
5138 __save_flags<_CharT, _Traits> __lx(__is);
5139 __is.flags(ios_base::dec | ios_base::skipws);
5140 result_type __alpha;
5142 __is >> __alpha >> __beta;
5144 __x.param(param_type(__alpha, __beta));
5148 // negative_binomial_distribution
5150 template<class _IntType = int>
5151 class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
5155 typedef _IntType result_type;
5157 class _LIBCPP_TEMPLATE_VIS param_type
5162 typedef negative_binomial_distribution distribution_type;
5164 _LIBCPP_INLINE_VISIBILITY
5165 explicit param_type(result_type __k = 1, double __p = 0.5)
5166 : __k_(__k), __p_(__p) {}
5168 _LIBCPP_INLINE_VISIBILITY
5169 result_type k() const {return __k_;}
5170 _LIBCPP_INLINE_VISIBILITY
5171 double p() const {return __p_;}
5173 friend _LIBCPP_INLINE_VISIBILITY
5174 bool operator==(const param_type& __x, const param_type& __y)
5175 {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
5176 friend _LIBCPP_INLINE_VISIBILITY
5177 bool operator!=(const param_type& __x, const param_type& __y)
5178 {return !(__x == __y);}
5185 // constructor and reset functions
5186 _LIBCPP_INLINE_VISIBILITY
5187 explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
5189 _LIBCPP_INLINE_VISIBILITY
5190 explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
5191 _LIBCPP_INLINE_VISIBILITY
5194 // generating functions
5195 template<class _URNG>
5196 _LIBCPP_INLINE_VISIBILITY
5197 result_type operator()(_URNG& __g)
5198 {return (*this)(__g, __p_);}
5199 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
5201 // property functions
5202 _LIBCPP_INLINE_VISIBILITY
5203 result_type k() const {return __p_.k();}
5204 _LIBCPP_INLINE_VISIBILITY
5205 double p() const {return __p_.p();}
5207 _LIBCPP_INLINE_VISIBILITY
5208 param_type param() const {return __p_;}
5209 _LIBCPP_INLINE_VISIBILITY
5210 void param(const param_type& __p) {__p_ = __p;}
5212 _LIBCPP_INLINE_VISIBILITY
5213 result_type min() const {return 0;}
5214 _LIBCPP_INLINE_VISIBILITY
5215 result_type max() const {return numeric_limits<result_type>::max();}
5217 friend _LIBCPP_INLINE_VISIBILITY
5218 bool operator==(const negative_binomial_distribution& __x,
5219 const negative_binomial_distribution& __y)
5220 {return __x.__p_ == __y.__p_;}
5221 friend _LIBCPP_INLINE_VISIBILITY
5222 bool operator!=(const negative_binomial_distribution& __x,
5223 const negative_binomial_distribution& __y)
5224 {return !(__x == __y);}
5227 template <class _IntType>
5228 template<class _URNG>
5230 negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
5232 result_type __k = __pr.k();
5233 double __p = __pr.p();
5234 if (__k <= 21 * __p)
5236 bernoulli_distribution __gen(__p);
5237 result_type __f = 0;
5238 result_type __s = 0;
5248 return poisson_distribution<result_type>(gamma_distribution<double>
5249 (__k, (1-__p)/__p)(__urng))(__urng);
5252 template <class _CharT, class _Traits, class _IntType>
5253 basic_ostream<_CharT, _Traits>&
5254 operator<<(basic_ostream<_CharT, _Traits>& __os,
5255 const negative_binomial_distribution<_IntType>& __x)
5257 __save_flags<_CharT, _Traits> __lx(__os);
5258 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5259 ios_base::scientific);
5260 _CharT __sp = __os.widen(' ');
5262 return __os << __x.k() << __sp << __x.p();
5265 template <class _CharT, class _Traits, class _IntType>
5266 basic_istream<_CharT, _Traits>&
5267 operator>>(basic_istream<_CharT, _Traits>& __is,
5268 negative_binomial_distribution<_IntType>& __x)
5270 typedef negative_binomial_distribution<_IntType> _Eng;
5271 typedef typename _Eng::result_type result_type;
5272 typedef typename _Eng::param_type param_type;
5273 __save_flags<_CharT, _Traits> __lx(__is);
5274 __is.flags(ios_base::dec | ios_base::skipws);
5279 __x.param(param_type(__k, __p));
5283 // geometric_distribution
5285 template<class _IntType = int>
5286 class _LIBCPP_TEMPLATE_VIS geometric_distribution
5290 typedef _IntType result_type;
5292 class _LIBCPP_TEMPLATE_VIS param_type
5296 typedef geometric_distribution distribution_type;
5298 _LIBCPP_INLINE_VISIBILITY
5299 explicit param_type(double __p = 0.5) : __p_(__p) {}
5301 _LIBCPP_INLINE_VISIBILITY
5302 double p() const {return __p_;}
5304 friend _LIBCPP_INLINE_VISIBILITY
5305 bool operator==(const param_type& __x, const param_type& __y)
5306 {return __x.__p_ == __y.__p_;}
5307 friend _LIBCPP_INLINE_VISIBILITY
5308 bool operator!=(const param_type& __x, const param_type& __y)
5309 {return !(__x == __y);}
5316 // constructors and reset functions
5317 _LIBCPP_INLINE_VISIBILITY
5318 explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
5319 _LIBCPP_INLINE_VISIBILITY
5320 explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
5321 _LIBCPP_INLINE_VISIBILITY
5324 // generating functions
5325 template<class _URNG>
5326 _LIBCPP_INLINE_VISIBILITY
5327 result_type operator()(_URNG& __g)
5328 {return (*this)(__g, __p_);}
5329 template<class _URNG>
5330 _LIBCPP_INLINE_VISIBILITY
5331 result_type operator()(_URNG& __g, const param_type& __p)
5332 {return negative_binomial_distribution<result_type>(1, __p.p())(__g);}
5334 // property functions
5335 _LIBCPP_INLINE_VISIBILITY
5336 double p() const {return __p_.p();}
5338 _LIBCPP_INLINE_VISIBILITY
5339 param_type param() const {return __p_;}
5340 _LIBCPP_INLINE_VISIBILITY
5341 void param(const param_type& __p) {__p_ = __p;}
5343 _LIBCPP_INLINE_VISIBILITY
5344 result_type min() const {return 0;}
5345 _LIBCPP_INLINE_VISIBILITY
5346 result_type max() const {return numeric_limits<result_type>::max();}
5348 friend _LIBCPP_INLINE_VISIBILITY
5349 bool operator==(const geometric_distribution& __x,
5350 const geometric_distribution& __y)
5351 {return __x.__p_ == __y.__p_;}
5352 friend _LIBCPP_INLINE_VISIBILITY
5353 bool operator!=(const geometric_distribution& __x,
5354 const geometric_distribution& __y)
5355 {return !(__x == __y);}
5358 template <class _CharT, class _Traits, class _IntType>
5359 basic_ostream<_CharT, _Traits>&
5360 operator<<(basic_ostream<_CharT, _Traits>& __os,
5361 const geometric_distribution<_IntType>& __x)
5363 __save_flags<_CharT, _Traits> __lx(__os);
5364 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5365 ios_base::scientific);
5366 return __os << __x.p();
5369 template <class _CharT, class _Traits, class _IntType>
5370 basic_istream<_CharT, _Traits>&
5371 operator>>(basic_istream<_CharT, _Traits>& __is,
5372 geometric_distribution<_IntType>& __x)
5374 typedef geometric_distribution<_IntType> _Eng;
5375 typedef typename _Eng::param_type param_type;
5376 __save_flags<_CharT, _Traits> __lx(__is);
5377 __is.flags(ios_base::dec | ios_base::skipws);
5381 __x.param(param_type(__p));
5385 // chi_squared_distribution
5387 template<class _RealType = double>
5388 class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
5392 typedef _RealType result_type;
5394 class _LIBCPP_TEMPLATE_VIS param_type
5398 typedef chi_squared_distribution distribution_type;
5400 _LIBCPP_INLINE_VISIBILITY
5401 explicit param_type(result_type __n = 1) : __n_(__n) {}
5403 _LIBCPP_INLINE_VISIBILITY
5404 result_type n() const {return __n_;}
5406 friend _LIBCPP_INLINE_VISIBILITY
5407 bool operator==(const param_type& __x, const param_type& __y)
5408 {return __x.__n_ == __y.__n_;}
5409 friend _LIBCPP_INLINE_VISIBILITY
5410 bool operator!=(const param_type& __x, const param_type& __y)
5411 {return !(__x == __y);}
5418 // constructor and reset functions
5419 _LIBCPP_INLINE_VISIBILITY
5420 explicit chi_squared_distribution(result_type __n = 1)
5421 : __p_(param_type(__n)) {}
5422 _LIBCPP_INLINE_VISIBILITY
5423 explicit chi_squared_distribution(const param_type& __p)
5425 _LIBCPP_INLINE_VISIBILITY
5428 // generating functions
5429 template<class _URNG>
5430 _LIBCPP_INLINE_VISIBILITY
5431 result_type operator()(_URNG& __g)
5432 {return (*this)(__g, __p_);}
5433 template<class _URNG>
5434 _LIBCPP_INLINE_VISIBILITY
5435 result_type operator()(_URNG& __g, const param_type& __p)
5436 {return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}
5438 // property functions
5439 _LIBCPP_INLINE_VISIBILITY
5440 result_type n() const {return __p_.n();}
5442 _LIBCPP_INLINE_VISIBILITY
5443 param_type param() const {return __p_;}
5444 _LIBCPP_INLINE_VISIBILITY
5445 void param(const param_type& __p) {__p_ = __p;}
5447 _LIBCPP_INLINE_VISIBILITY
5448 result_type min() const {return 0;}
5449 _LIBCPP_INLINE_VISIBILITY
5450 result_type max() const {return numeric_limits<result_type>::infinity();}
5452 friend _LIBCPP_INLINE_VISIBILITY
5453 bool operator==(const chi_squared_distribution& __x,
5454 const chi_squared_distribution& __y)
5455 {return __x.__p_ == __y.__p_;}
5456 friend _LIBCPP_INLINE_VISIBILITY
5457 bool operator!=(const chi_squared_distribution& __x,
5458 const chi_squared_distribution& __y)
5459 {return !(__x == __y);}
5462 template <class _CharT, class _Traits, class _RT>
5463 basic_ostream<_CharT, _Traits>&
5464 operator<<(basic_ostream<_CharT, _Traits>& __os,
5465 const chi_squared_distribution<_RT>& __x)
5467 __save_flags<_CharT, _Traits> __lx(__os);
5468 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5469 ios_base::scientific);
5474 template <class _CharT, class _Traits, class _RT>
5475 basic_istream<_CharT, _Traits>&
5476 operator>>(basic_istream<_CharT, _Traits>& __is,
5477 chi_squared_distribution<_RT>& __x)
5479 typedef chi_squared_distribution<_RT> _Eng;
5480 typedef typename _Eng::result_type result_type;
5481 typedef typename _Eng::param_type param_type;
5482 __save_flags<_CharT, _Traits> __lx(__is);
5483 __is.flags(ios_base::dec | ios_base::skipws);
5487 __x.param(param_type(__n));
5491 // cauchy_distribution
5493 template<class _RealType = double>
5494 class _LIBCPP_TEMPLATE_VIS cauchy_distribution
5498 typedef _RealType result_type;
5500 class _LIBCPP_TEMPLATE_VIS param_type
5505 typedef cauchy_distribution distribution_type;
5507 _LIBCPP_INLINE_VISIBILITY
5508 explicit param_type(result_type __a = 0, result_type __b = 1)
5509 : __a_(__a), __b_(__b) {}
5511 _LIBCPP_INLINE_VISIBILITY
5512 result_type a() const {return __a_;}
5513 _LIBCPP_INLINE_VISIBILITY
5514 result_type b() const {return __b_;}
5516 friend _LIBCPP_INLINE_VISIBILITY
5517 bool operator==(const param_type& __x, const param_type& __y)
5518 {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
5519 friend _LIBCPP_INLINE_VISIBILITY
5520 bool operator!=(const param_type& __x, const param_type& __y)
5521 {return !(__x == __y);}
5528 // constructor and reset functions
5529 _LIBCPP_INLINE_VISIBILITY
5530 explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
5531 : __p_(param_type(__a, __b)) {}
5532 _LIBCPP_INLINE_VISIBILITY
5533 explicit cauchy_distribution(const param_type& __p)
5535 _LIBCPP_INLINE_VISIBILITY
5538 // generating functions
5539 template<class _URNG>
5540 _LIBCPP_INLINE_VISIBILITY
5541 result_type operator()(_URNG& __g)
5542 {return (*this)(__g, __p_);}
5543 template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
5545 // property functions
5546 _LIBCPP_INLINE_VISIBILITY
5547 result_type a() const {return __p_.a();}
5548 _LIBCPP_INLINE_VISIBILITY
5549 result_type b() const {return __p_.b();}
5551 _LIBCPP_INLINE_VISIBILITY
5552 param_type param() const {return __p_;}
5553 _LIBCPP_INLINE_VISIBILITY
5554 void param(const param_type& __p) {__p_ = __p;}
5556 _LIBCPP_INLINE_VISIBILITY
5557 result_type min() const {return -numeric_limits<result_type>::infinity();}
5558 _LIBCPP_INLINE_VISIBILITY
5559 result_type max() const {return numeric_limits<result_type>::infinity();}
5561 friend _LIBCPP_INLINE_VISIBILITY
5562 bool operator==(const cauchy_distribution& __x,
5563 const cauchy_distribution& __y)
5564 {return __x.__p_ == __y.__p_;}
5565 friend _LIBCPP_INLINE_VISIBILITY
5566 bool operator!=(const cauchy_distribution& __x,
5567 const cauchy_distribution& __y)
5568 {return !(__x == __y);}
5571 template <class _RealType>
5572 template<class _URNG>
5575 cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
5577 uniform_real_distribution<result_type> __gen;
5578 // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
5579 return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
5582 template <class _CharT, class _Traits, class _RT>
5583 basic_ostream<_CharT, _Traits>&
5584 operator<<(basic_ostream<_CharT, _Traits>& __os,
5585 const cauchy_distribution<_RT>& __x)
5587 __save_flags<_CharT, _Traits> __lx(__os);
5588 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5589 ios_base::scientific);
5590 _CharT __sp = __os.widen(' ');
5592 __os << __x.a() << __sp << __x.b();
5596 template <class _CharT, class _Traits, class _RT>
5597 basic_istream<_CharT, _Traits>&
5598 operator>>(basic_istream<_CharT, _Traits>& __is,
5599 cauchy_distribution<_RT>& __x)
5601 typedef cauchy_distribution<_RT> _Eng;
5602 typedef typename _Eng::result_type result_type;
5603 typedef typename _Eng::param_type param_type;
5604 __save_flags<_CharT, _Traits> __lx(__is);
5605 __is.flags(ios_base::dec | ios_base::skipws);
5610 __x.param(param_type(__a, __b));
5614 // fisher_f_distribution
5616 template<class _RealType = double>
5617 class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
5621 typedef _RealType result_type;
5623 class _LIBCPP_TEMPLATE_VIS param_type
5628 typedef fisher_f_distribution distribution_type;
5630 _LIBCPP_INLINE_VISIBILITY
5631 explicit param_type(result_type __m = 1, result_type __n = 1)
5632 : __m_(__m), __n_(__n) {}
5634 _LIBCPP_INLINE_VISIBILITY
5635 result_type m() const {return __m_;}
5636 _LIBCPP_INLINE_VISIBILITY
5637 result_type n() const {return __n_;}
5639 friend _LIBCPP_INLINE_VISIBILITY
5640 bool operator==(const param_type& __x, const param_type& __y)
5641 {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
5642 friend _LIBCPP_INLINE_VISIBILITY
5643 bool operator!=(const param_type& __x, const param_type& __y)
5644 {return !(__x == __y);}
5651 // constructor and reset functions
5652 _LIBCPP_INLINE_VISIBILITY
5653 explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
5654 : __p_(param_type(__m, __n)) {}
5655 _LIBCPP_INLINE_VISIBILITY
5656 explicit fisher_f_distribution(const param_type& __p)
5658 _LIBCPP_INLINE_VISIBILITY
5661 // generating functions
5662 template<class _URNG>
5663 _LIBCPP_INLINE_VISIBILITY
5664 result_type operator()(_URNG& __g)
5665 {return (*this)(__g, __p_);}
5666 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
5668 // property functions
5669 _LIBCPP_INLINE_VISIBILITY
5670 result_type m() const {return __p_.m();}
5671 _LIBCPP_INLINE_VISIBILITY
5672 result_type n() const {return __p_.n();}
5674 _LIBCPP_INLINE_VISIBILITY
5675 param_type param() const {return __p_;}
5676 _LIBCPP_INLINE_VISIBILITY
5677 void param(const param_type& __p) {__p_ = __p;}
5679 _LIBCPP_INLINE_VISIBILITY
5680 result_type min() const {return 0;}
5681 _LIBCPP_INLINE_VISIBILITY
5682 result_type max() const {return numeric_limits<result_type>::infinity();}
5684 friend _LIBCPP_INLINE_VISIBILITY
5685 bool operator==(const fisher_f_distribution& __x,
5686 const fisher_f_distribution& __y)
5687 {return __x.__p_ == __y.__p_;}
5688 friend _LIBCPP_INLINE_VISIBILITY
5689 bool operator!=(const fisher_f_distribution& __x,
5690 const fisher_f_distribution& __y)
5691 {return !(__x == __y);}
5694 template <class _RealType>
5695 template<class _URNG>
5697 fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
5699 gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
5700 gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
5701 return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
5704 template <class _CharT, class _Traits, class _RT>
5705 basic_ostream<_CharT, _Traits>&
5706 operator<<(basic_ostream<_CharT, _Traits>& __os,
5707 const fisher_f_distribution<_RT>& __x)
5709 __save_flags<_CharT, _Traits> __lx(__os);
5710 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5711 ios_base::scientific);
5712 _CharT __sp = __os.widen(' ');
5714 __os << __x.m() << __sp << __x.n();
5718 template <class _CharT, class _Traits, class _RT>
5719 basic_istream<_CharT, _Traits>&
5720 operator>>(basic_istream<_CharT, _Traits>& __is,
5721 fisher_f_distribution<_RT>& __x)
5723 typedef fisher_f_distribution<_RT> _Eng;
5724 typedef typename _Eng::result_type result_type;
5725 typedef typename _Eng::param_type param_type;
5726 __save_flags<_CharT, _Traits> __lx(__is);
5727 __is.flags(ios_base::dec | ios_base::skipws);
5732 __x.param(param_type(__m, __n));
5736 // student_t_distribution
5738 template<class _RealType = double>
5739 class _LIBCPP_TEMPLATE_VIS student_t_distribution
5743 typedef _RealType result_type;
5745 class _LIBCPP_TEMPLATE_VIS param_type
5749 typedef student_t_distribution distribution_type;
5751 _LIBCPP_INLINE_VISIBILITY
5752 explicit param_type(result_type __n = 1) : __n_(__n) {}
5754 _LIBCPP_INLINE_VISIBILITY
5755 result_type n() const {return __n_;}
5757 friend _LIBCPP_INLINE_VISIBILITY
5758 bool operator==(const param_type& __x, const param_type& __y)
5759 {return __x.__n_ == __y.__n_;}
5760 friend _LIBCPP_INLINE_VISIBILITY
5761 bool operator!=(const param_type& __x, const param_type& __y)
5762 {return !(__x == __y);}
5767 normal_distribution<result_type> __nd_;
5770 // constructor and reset functions
5771 _LIBCPP_INLINE_VISIBILITY
5772 explicit student_t_distribution(result_type __n = 1)
5773 : __p_(param_type(__n)) {}
5774 _LIBCPP_INLINE_VISIBILITY
5775 explicit student_t_distribution(const param_type& __p)
5777 _LIBCPP_INLINE_VISIBILITY
5778 void reset() {__nd_.reset();}
5780 // generating functions
5781 template<class _URNG>
5782 _LIBCPP_INLINE_VISIBILITY
5783 result_type operator()(_URNG& __g)
5784 {return (*this)(__g, __p_);}
5785 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
5787 // property functions
5788 _LIBCPP_INLINE_VISIBILITY
5789 result_type n() const {return __p_.n();}
5791 _LIBCPP_INLINE_VISIBILITY
5792 param_type param() const {return __p_;}
5793 _LIBCPP_INLINE_VISIBILITY
5794 void param(const param_type& __p) {__p_ = __p;}
5796 _LIBCPP_INLINE_VISIBILITY
5797 result_type min() const {return -numeric_limits<result_type>::infinity();}
5798 _LIBCPP_INLINE_VISIBILITY
5799 result_type max() const {return numeric_limits<result_type>::infinity();}
5801 friend _LIBCPP_INLINE_VISIBILITY
5802 bool operator==(const student_t_distribution& __x,
5803 const student_t_distribution& __y)
5804 {return __x.__p_ == __y.__p_;}
5805 friend _LIBCPP_INLINE_VISIBILITY
5806 bool operator!=(const student_t_distribution& __x,
5807 const student_t_distribution& __y)
5808 {return !(__x == __y);}
5811 template <class _RealType>
5812 template<class _URNG>
5814 student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
5816 gamma_distribution<result_type> __gd(__p.n() * .5, 2);
5817 return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
5820 template <class _CharT, class _Traits, class _RT>
5821 basic_ostream<_CharT, _Traits>&
5822 operator<<(basic_ostream<_CharT, _Traits>& __os,
5823 const student_t_distribution<_RT>& __x)
5825 __save_flags<_CharT, _Traits> __lx(__os);
5826 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
5827 ios_base::scientific);
5832 template <class _CharT, class _Traits, class _RT>
5833 basic_istream<_CharT, _Traits>&
5834 operator>>(basic_istream<_CharT, _Traits>& __is,
5835 student_t_distribution<_RT>& __x)
5837 typedef student_t_distribution<_RT> _Eng;
5838 typedef typename _Eng::result_type result_type;
5839 typedef typename _Eng::param_type param_type;
5840 __save_flags<_CharT, _Traits> __lx(__is);
5841 __is.flags(ios_base::dec | ios_base::skipws);
5845 __x.param(param_type(__n));
5849 // discrete_distribution
5851 template<class _IntType = int>
5852 class _LIBCPP_TEMPLATE_VIS discrete_distribution
5856 typedef _IntType result_type;
5858 class _LIBCPP_TEMPLATE_VIS param_type
5860 vector<double> __p_;
5862 typedef discrete_distribution distribution_type;
5864 _LIBCPP_INLINE_VISIBILITY
5866 template<class _InputIterator>
5867 _LIBCPP_INLINE_VISIBILITY
5868 param_type(_InputIterator __f, _InputIterator __l)
5869 : __p_(__f, __l) {__init();}
5870 #ifndef _LIBCPP_CXX03_LANG
5871 _LIBCPP_INLINE_VISIBILITY
5872 param_type(initializer_list<double> __wl)
5873 : __p_(__wl.begin(), __wl.end()) {__init();}
5874 #endif // _LIBCPP_CXX03_LANG
5875 template<class _UnaryOperation>
5876 param_type(size_t __nw, double __xmin, double __xmax,
5877 _UnaryOperation __fw);
5879 vector<double> probabilities() const;
5881 friend _LIBCPP_INLINE_VISIBILITY
5882 bool operator==(const param_type& __x, const param_type& __y)
5883 {return __x.__p_ == __y.__p_;}
5884 friend _LIBCPP_INLINE_VISIBILITY
5885 bool operator!=(const param_type& __x, const param_type& __y)
5886 {return !(__x == __y);}
5891 friend class discrete_distribution;
5893 template <class _CharT, class _Traits, class _IT>
5895 basic_ostream<_CharT, _Traits>&
5896 operator<<(basic_ostream<_CharT, _Traits>& __os,
5897 const discrete_distribution<_IT>& __x);
5899 template <class _CharT, class _Traits, class _IT>
5901 basic_istream<_CharT, _Traits>&
5902 operator>>(basic_istream<_CharT, _Traits>& __is,
5903 discrete_distribution<_IT>& __x);
5910 // constructor and reset functions
5911 _LIBCPP_INLINE_VISIBILITY
5912 discrete_distribution() {}
5913 template<class _InputIterator>
5914 _LIBCPP_INLINE_VISIBILITY
5915 discrete_distribution(_InputIterator __f, _InputIterator __l)
5917 #ifndef _LIBCPP_CXX03_LANG
5918 _LIBCPP_INLINE_VISIBILITY
5919 discrete_distribution(initializer_list<double> __wl)
5921 #endif // _LIBCPP_CXX03_LANG
5922 template<class _UnaryOperation>
5923 _LIBCPP_INLINE_VISIBILITY
5924 discrete_distribution(size_t __nw, double __xmin, double __xmax,
5925 _UnaryOperation __fw)
5926 : __p_(__nw, __xmin, __xmax, __fw) {}
5927 _LIBCPP_INLINE_VISIBILITY
5928 explicit discrete_distribution(const param_type& __p)
5930 _LIBCPP_INLINE_VISIBILITY
5933 // generating functions
5934 template<class _URNG>
5935 _LIBCPP_INLINE_VISIBILITY
5936 result_type operator()(_URNG& __g)
5937 {return (*this)(__g, __p_);}
5938 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
5940 // property functions
5941 _LIBCPP_INLINE_VISIBILITY
5942 vector<double> probabilities() const {return __p_.probabilities();}
5944 _LIBCPP_INLINE_VISIBILITY
5945 param_type param() const {return __p_;}
5946 _LIBCPP_INLINE_VISIBILITY
5947 void param(const param_type& __p) {__p_ = __p;}
5949 _LIBCPP_INLINE_VISIBILITY
5950 result_type min() const {return 0;}
5951 _LIBCPP_INLINE_VISIBILITY
5952 result_type max() const {return __p_.__p_.size();}
5954 friend _LIBCPP_INLINE_VISIBILITY
5955 bool operator==(const discrete_distribution& __x,
5956 const discrete_distribution& __y)
5957 {return __x.__p_ == __y.__p_;}
5958 friend _LIBCPP_INLINE_VISIBILITY
5959 bool operator!=(const discrete_distribution& __x,
5960 const discrete_distribution& __y)
5961 {return !(__x == __y);}
5963 template <class _CharT, class _Traits, class _IT>
5965 basic_ostream<_CharT, _Traits>&
5966 operator<<(basic_ostream<_CharT, _Traits>& __os,
5967 const discrete_distribution<_IT>& __x);
5969 template <class _CharT, class _Traits, class _IT>
5971 basic_istream<_CharT, _Traits>&
5972 operator>>(basic_istream<_CharT, _Traits>& __is,
5973 discrete_distribution<_IT>& __x);
5976 template<class _IntType>
5977 template<class _UnaryOperation>
5978 discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
5981 _UnaryOperation __fw)
5985 __p_.reserve(__nw - 1);
5986 double __d = (__xmax - __xmin) / __nw;
5987 double __d2 = __d / 2;
5988 for (size_t __k = 0; __k < __nw; ++__k)
5989 __p_.push_back(__fw(__xmin + __k * __d + __d2));
5994 template<class _IntType>
5996 discrete_distribution<_IntType>::param_type::__init()
6000 if (__p_.size() > 1)
6002 double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
6003 for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
6006 vector<double> __t(__p_.size() - 1);
6007 _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
6013 __p_.shrink_to_fit();
6018 template<class _IntType>
6020 discrete_distribution<_IntType>::param_type::probabilities() const
6022 size_t __n = __p_.size();
6023 _VSTD::vector<double> __p(__n+1);
6024 _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
6026 __p[__n] = 1 - __p_[__n-1];
6032 template<class _IntType>
6033 template<class _URNG>
6035 discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
6037 uniform_real_distribution<double> __gen;
6038 return static_cast<_IntType>(
6039 _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
6043 template <class _CharT, class _Traits, class _IT>
6044 basic_ostream<_CharT, _Traits>&
6045 operator<<(basic_ostream<_CharT, _Traits>& __os,
6046 const discrete_distribution<_IT>& __x)
6048 __save_flags<_CharT, _Traits> __lx(__os);
6049 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
6050 ios_base::scientific);
6051 _CharT __sp = __os.widen(' ');
6053 size_t __n = __x.__p_.__p_.size();
6055 for (size_t __i = 0; __i < __n; ++__i)
6056 __os << __sp << __x.__p_.__p_[__i];
6060 template <class _CharT, class _Traits, class _IT>
6061 basic_istream<_CharT, _Traits>&
6062 operator>>(basic_istream<_CharT, _Traits>& __is,
6063 discrete_distribution<_IT>& __x)
6065 __save_flags<_CharT, _Traits> __lx(__is);
6066 __is.flags(ios_base::dec | ios_base::skipws);
6069 vector<double> __p(__n);
6070 for (size_t __i = 0; __i < __n; ++__i)
6073 swap(__x.__p_.__p_, __p);
6077 // piecewise_constant_distribution
6079 template<class _RealType = double>
6080 class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
6084 typedef _RealType result_type;
6086 class _LIBCPP_TEMPLATE_VIS param_type
6088 vector<result_type> __b_;
6089 vector<result_type> __densities_;
6090 vector<result_type> __areas_;
6092 typedef piecewise_constant_distribution distribution_type;
6095 template<class _InputIteratorB, class _InputIteratorW>
6096 param_type(_InputIteratorB __fB, _InputIteratorB __lB,
6097 _InputIteratorW __fW);
6098 #ifndef _LIBCPP_CXX03_LANG
6099 template<class _UnaryOperation>
6100 param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
6101 #endif // _LIBCPP_CXX03_LANG
6102 template<class _UnaryOperation>
6103 param_type(size_t __nw, result_type __xmin, result_type __xmax,
6104 _UnaryOperation __fw);
6105 param_type & operator=(const param_type& __rhs);
6107 _LIBCPP_INLINE_VISIBILITY
6108 vector<result_type> intervals() const {return __b_;}
6109 _LIBCPP_INLINE_VISIBILITY
6110 vector<result_type> densities() const {return __densities_;}
6112 friend _LIBCPP_INLINE_VISIBILITY
6113 bool operator==(const param_type& __x, const param_type& __y)
6114 {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
6115 friend _LIBCPP_INLINE_VISIBILITY
6116 bool operator!=(const param_type& __x, const param_type& __y)
6117 {return !(__x == __y);}
6122 friend class piecewise_constant_distribution;
6124 template <class _CharT, class _Traits, class _RT>
6126 basic_ostream<_CharT, _Traits>&
6127 operator<<(basic_ostream<_CharT, _Traits>& __os,
6128 const piecewise_constant_distribution<_RT>& __x);
6130 template <class _CharT, class _Traits, class _RT>
6132 basic_istream<_CharT, _Traits>&
6133 operator>>(basic_istream<_CharT, _Traits>& __is,
6134 piecewise_constant_distribution<_RT>& __x);
6141 // constructor and reset functions
6142 _LIBCPP_INLINE_VISIBILITY
6143 piecewise_constant_distribution() {}
6144 template<class _InputIteratorB, class _InputIteratorW>
6145 _LIBCPP_INLINE_VISIBILITY
6146 piecewise_constant_distribution(_InputIteratorB __fB,
6147 _InputIteratorB __lB,
6148 _InputIteratorW __fW)
6149 : __p_(__fB, __lB, __fW) {}
6151 #ifndef _LIBCPP_CXX03_LANG
6152 template<class _UnaryOperation>
6153 _LIBCPP_INLINE_VISIBILITY
6154 piecewise_constant_distribution(initializer_list<result_type> __bl,
6155 _UnaryOperation __fw)
6156 : __p_(__bl, __fw) {}
6157 #endif // _LIBCPP_CXX03_LANG
6159 template<class _UnaryOperation>
6160 _LIBCPP_INLINE_VISIBILITY
6161 piecewise_constant_distribution(size_t __nw, result_type __xmin,
6162 result_type __xmax, _UnaryOperation __fw)
6163 : __p_(__nw, __xmin, __xmax, __fw) {}
6165 _LIBCPP_INLINE_VISIBILITY
6166 explicit piecewise_constant_distribution(const param_type& __p)
6169 _LIBCPP_INLINE_VISIBILITY
6172 // generating functions
6173 template<class _URNG>
6174 _LIBCPP_INLINE_VISIBILITY
6175 result_type operator()(_URNG& __g)
6176 {return (*this)(__g, __p_);}
6177 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
6179 // property functions
6180 _LIBCPP_INLINE_VISIBILITY
6181 vector<result_type> intervals() const {return __p_.intervals();}
6182 _LIBCPP_INLINE_VISIBILITY
6183 vector<result_type> densities() const {return __p_.densities();}
6185 _LIBCPP_INLINE_VISIBILITY
6186 param_type param() const {return __p_;}
6187 _LIBCPP_INLINE_VISIBILITY
6188 void param(const param_type& __p) {__p_ = __p;}
6190 _LIBCPP_INLINE_VISIBILITY
6191 result_type min() const {return __p_.__b_.front();}
6192 _LIBCPP_INLINE_VISIBILITY
6193 result_type max() const {return __p_.__b_.back();}
6195 friend _LIBCPP_INLINE_VISIBILITY
6196 bool operator==(const piecewise_constant_distribution& __x,
6197 const piecewise_constant_distribution& __y)
6198 {return __x.__p_ == __y.__p_;}
6199 friend _LIBCPP_INLINE_VISIBILITY
6200 bool operator!=(const piecewise_constant_distribution& __x,
6201 const piecewise_constant_distribution& __y)
6202 {return !(__x == __y);}
6204 template <class _CharT, class _Traits, class _RT>
6206 basic_ostream<_CharT, _Traits>&
6207 operator<<(basic_ostream<_CharT, _Traits>& __os,
6208 const piecewise_constant_distribution<_RT>& __x);
6210 template <class _CharT, class _Traits, class _RT>
6212 basic_istream<_CharT, _Traits>&
6213 operator>>(basic_istream<_CharT, _Traits>& __is,
6214 piecewise_constant_distribution<_RT>& __x);
6217 template<class _RealType>
6218 typename piecewise_constant_distribution<_RealType>::param_type &
6219 piecewise_constant_distribution<_RealType>::param_type::operator=
6220 (const param_type& __rhs)
6223 __b_.reserve (__rhs.__b_.size ());
6224 __densities_.reserve(__rhs.__densities_.size());
6225 __areas_.reserve (__rhs.__areas_.size());
6227 // These can not throw
6229 __densities_ = __rhs.__densities_;
6230 __areas_ = __rhs.__areas_;
6234 template<class _RealType>
6236 piecewise_constant_distribution<_RealType>::param_type::__init()
6238 // __densities_ contains non-normalized areas
6239 result_type __total_area = _VSTD::accumulate(__densities_.begin(),
6242 for (size_t __i = 0; __i < __densities_.size(); ++__i)
6243 __densities_[__i] /= __total_area;
6244 // __densities_ contains normalized areas
6245 __areas_.assign(__densities_.size(), result_type());
6246 _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
6247 __areas_.begin() + 1);
6248 // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
6249 __densities_.back() = 1 - __areas_.back(); // correct round off error
6250 for (size_t __i = 0; __i < __densities_.size(); ++__i)
6251 __densities_[__i] /= (__b_[__i+1] - __b_[__i]);
6252 // __densities_ now contains __densities_
6255 template<class _RealType>
6256 piecewise_constant_distribution<_RealType>::param_type::param_type()
6258 __densities_(1, 1.0),
6264 template<class _RealType>
6265 template<class _InputIteratorB, class _InputIteratorW>
6266 piecewise_constant_distribution<_RealType>::param_type::param_type(
6267 _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
6270 if (__b_.size() < 2)
6275 __densities_.assign(1, 1.0);
6276 __areas_.assign(1, 0.0);
6280 __densities_.reserve(__b_.size() - 1);
6281 for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
6282 __densities_.push_back(*__fW);
6287 #ifndef _LIBCPP_CXX03_LANG
6289 template<class _RealType>
6290 template<class _UnaryOperation>
6291 piecewise_constant_distribution<_RealType>::param_type::param_type(
6292 initializer_list<result_type> __bl, _UnaryOperation __fw)
6293 : __b_(__bl.begin(), __bl.end())
6295 if (__b_.size() < 2)
6300 __densities_.assign(1, 1.0);
6301 __areas_.assign(1, 0.0);
6305 __densities_.reserve(__b_.size() - 1);
6306 for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
6307 __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
6312 #endif // _LIBCPP_CXX03_LANG
6314 template<class _RealType>
6315 template<class _UnaryOperation>
6316 piecewise_constant_distribution<_RealType>::param_type::param_type(
6317 size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
6318 : __b_(__nw == 0 ? 2 : __nw + 1)
6320 size_t __n = __b_.size() - 1;
6321 result_type __d = (__xmax - __xmin) / __n;
6322 __densities_.reserve(__n);
6323 for (size_t __i = 0; __i < __n; ++__i)
6325 __b_[__i] = __xmin + __i * __d;
6326 __densities_.push_back(__fw(__b_[__i] + __d*.5));
6332 template<class _RealType>
6333 template<class _URNG>
6335 piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
6337 typedef uniform_real_distribution<result_type> _Gen;
6338 result_type __u = _Gen()(__g);
6339 ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
6340 __u) - __p.__areas_.begin() - 1;
6341 return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
6344 template <class _CharT, class _Traits, class _RT>
6345 basic_ostream<_CharT, _Traits>&
6346 operator<<(basic_ostream<_CharT, _Traits>& __os,
6347 const piecewise_constant_distribution<_RT>& __x)
6349 __save_flags<_CharT, _Traits> __lx(__os);
6350 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
6351 ios_base::scientific);
6352 _CharT __sp = __os.widen(' ');
6354 size_t __n = __x.__p_.__b_.size();
6356 for (size_t __i = 0; __i < __n; ++__i)
6357 __os << __sp << __x.__p_.__b_[__i];
6358 __n = __x.__p_.__densities_.size();
6359 __os << __sp << __n;
6360 for (size_t __i = 0; __i < __n; ++__i)
6361 __os << __sp << __x.__p_.__densities_[__i];
6362 __n = __x.__p_.__areas_.size();
6363 __os << __sp << __n;
6364 for (size_t __i = 0; __i < __n; ++__i)
6365 __os << __sp << __x.__p_.__areas_[__i];
6369 template <class _CharT, class _Traits, class _RT>
6370 basic_istream<_CharT, _Traits>&
6371 operator>>(basic_istream<_CharT, _Traits>& __is,
6372 piecewise_constant_distribution<_RT>& __x)
6374 typedef piecewise_constant_distribution<_RT> _Eng;
6375 typedef typename _Eng::result_type result_type;
6376 __save_flags<_CharT, _Traits> __lx(__is);
6377 __is.flags(ios_base::dec | ios_base::skipws);
6380 vector<result_type> __b(__n);
6381 for (size_t __i = 0; __i < __n; ++__i)
6384 vector<result_type> __densities(__n);
6385 for (size_t __i = 0; __i < __n; ++__i)
6386 __is >> __densities[__i];
6388 vector<result_type> __areas(__n);
6389 for (size_t __i = 0; __i < __n; ++__i)
6390 __is >> __areas[__i];
6393 swap(__x.__p_.__b_, __b);
6394 swap(__x.__p_.__densities_, __densities);
6395 swap(__x.__p_.__areas_, __areas);
6400 // piecewise_linear_distribution
6402 template<class _RealType = double>
6403 class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
6407 typedef _RealType result_type;
6409 class _LIBCPP_TEMPLATE_VIS param_type
6411 vector<result_type> __b_;
6412 vector<result_type> __densities_;
6413 vector<result_type> __areas_;
6415 typedef piecewise_linear_distribution distribution_type;
6418 template<class _InputIteratorB, class _InputIteratorW>
6419 param_type(_InputIteratorB __fB, _InputIteratorB __lB,
6420 _InputIteratorW __fW);
6421 #ifndef _LIBCPP_CXX03_LANG
6422 template<class _UnaryOperation>
6423 param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
6424 #endif // _LIBCPP_CXX03_LANG
6425 template<class _UnaryOperation>
6426 param_type(size_t __nw, result_type __xmin, result_type __xmax,
6427 _UnaryOperation __fw);
6428 param_type & operator=(const param_type& __rhs);
6430 _LIBCPP_INLINE_VISIBILITY
6431 vector<result_type> intervals() const {return __b_;}
6432 _LIBCPP_INLINE_VISIBILITY
6433 vector<result_type> densities() const {return __densities_;}
6435 friend _LIBCPP_INLINE_VISIBILITY
6436 bool operator==(const param_type& __x, const param_type& __y)
6437 {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
6438 friend _LIBCPP_INLINE_VISIBILITY
6439 bool operator!=(const param_type& __x, const param_type& __y)
6440 {return !(__x == __y);}
6445 friend class piecewise_linear_distribution;
6447 template <class _CharT, class _Traits, class _RT>
6449 basic_ostream<_CharT, _Traits>&
6450 operator<<(basic_ostream<_CharT, _Traits>& __os,
6451 const piecewise_linear_distribution<_RT>& __x);
6453 template <class _CharT, class _Traits, class _RT>
6455 basic_istream<_CharT, _Traits>&
6456 operator>>(basic_istream<_CharT, _Traits>& __is,
6457 piecewise_linear_distribution<_RT>& __x);
6464 // constructor and reset functions
6465 _LIBCPP_INLINE_VISIBILITY
6466 piecewise_linear_distribution() {}
6467 template<class _InputIteratorB, class _InputIteratorW>
6468 _LIBCPP_INLINE_VISIBILITY
6469 piecewise_linear_distribution(_InputIteratorB __fB,
6470 _InputIteratorB __lB,
6471 _InputIteratorW __fW)
6472 : __p_(__fB, __lB, __fW) {}
6474 #ifndef _LIBCPP_CXX03_LANG
6475 template<class _UnaryOperation>
6476 _LIBCPP_INLINE_VISIBILITY
6477 piecewise_linear_distribution(initializer_list<result_type> __bl,
6478 _UnaryOperation __fw)
6479 : __p_(__bl, __fw) {}
6480 #endif // _LIBCPP_CXX03_LANG
6482 template<class _UnaryOperation>
6483 _LIBCPP_INLINE_VISIBILITY
6484 piecewise_linear_distribution(size_t __nw, result_type __xmin,
6485 result_type __xmax, _UnaryOperation __fw)
6486 : __p_(__nw, __xmin, __xmax, __fw) {}
6488 _LIBCPP_INLINE_VISIBILITY
6489 explicit piecewise_linear_distribution(const param_type& __p)
6492 _LIBCPP_INLINE_VISIBILITY
6495 // generating functions
6496 template<class _URNG>
6497 _LIBCPP_INLINE_VISIBILITY
6498 result_type operator()(_URNG& __g)
6499 {return (*this)(__g, __p_);}
6500 template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
6502 // property functions
6503 _LIBCPP_INLINE_VISIBILITY
6504 vector<result_type> intervals() const {return __p_.intervals();}
6505 _LIBCPP_INLINE_VISIBILITY
6506 vector<result_type> densities() const {return __p_.densities();}
6508 _LIBCPP_INLINE_VISIBILITY
6509 param_type param() const {return __p_;}
6510 _LIBCPP_INLINE_VISIBILITY
6511 void param(const param_type& __p) {__p_ = __p;}
6513 _LIBCPP_INLINE_VISIBILITY
6514 result_type min() const {return __p_.__b_.front();}
6515 _LIBCPP_INLINE_VISIBILITY
6516 result_type max() const {return __p_.__b_.back();}
6518 friend _LIBCPP_INLINE_VISIBILITY
6519 bool operator==(const piecewise_linear_distribution& __x,
6520 const piecewise_linear_distribution& __y)
6521 {return __x.__p_ == __y.__p_;}
6522 friend _LIBCPP_INLINE_VISIBILITY
6523 bool operator!=(const piecewise_linear_distribution& __x,
6524 const piecewise_linear_distribution& __y)
6525 {return !(__x == __y);}
6527 template <class _CharT, class _Traits, class _RT>
6529 basic_ostream<_CharT, _Traits>&
6530 operator<<(basic_ostream<_CharT, _Traits>& __os,
6531 const piecewise_linear_distribution<_RT>& __x);
6533 template <class _CharT, class _Traits, class _RT>
6535 basic_istream<_CharT, _Traits>&
6536 operator>>(basic_istream<_CharT, _Traits>& __is,
6537 piecewise_linear_distribution<_RT>& __x);
6540 template<class _RealType>
6541 typename piecewise_linear_distribution<_RealType>::param_type &
6542 piecewise_linear_distribution<_RealType>::param_type::operator=
6543 (const param_type& __rhs)
6546 __b_.reserve (__rhs.__b_.size ());
6547 __densities_.reserve(__rhs.__densities_.size());
6548 __areas_.reserve (__rhs.__areas_.size());
6550 // These can not throw
6552 __densities_ = __rhs.__densities_;
6553 __areas_ = __rhs.__areas_;
6558 template<class _RealType>
6560 piecewise_linear_distribution<_RealType>::param_type::__init()
6562 __areas_.assign(__densities_.size() - 1, result_type());
6563 result_type _Sp = 0;
6564 for (size_t __i = 0; __i < __areas_.size(); ++__i)
6566 __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
6567 (__b_[__i+1] - __b_[__i]) * .5;
6568 _Sp += __areas_[__i];
6570 for (size_t __i = __areas_.size(); __i > 1;)
6573 __areas_[__i] = __areas_[__i-1] / _Sp;
6576 for (size_t __i = 1; __i < __areas_.size(); ++__i)
6577 __areas_[__i] += __areas_[__i-1];
6578 for (size_t __i = 0; __i < __densities_.size(); ++__i)
6579 __densities_[__i] /= _Sp;
6582 template<class _RealType>
6583 piecewise_linear_distribution<_RealType>::param_type::param_type()
6585 __densities_(2, 1.0),
6591 template<class _RealType>
6592 template<class _InputIteratorB, class _InputIteratorW>
6593 piecewise_linear_distribution<_RealType>::param_type::param_type(
6594 _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
6597 if (__b_.size() < 2)
6602 __densities_.assign(2, 1.0);
6603 __areas_.assign(1, 0.0);
6607 __densities_.reserve(__b_.size());
6608 for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
6609 __densities_.push_back(*__fW);
6614 #ifndef _LIBCPP_CXX03_LANG
6616 template<class _RealType>
6617 template<class _UnaryOperation>
6618 piecewise_linear_distribution<_RealType>::param_type::param_type(
6619 initializer_list<result_type> __bl, _UnaryOperation __fw)
6620 : __b_(__bl.begin(), __bl.end())
6622 if (__b_.size() < 2)
6627 __densities_.assign(2, 1.0);
6628 __areas_.assign(1, 0.0);
6632 __densities_.reserve(__b_.size());
6633 for (size_t __i = 0; __i < __b_.size(); ++__i)
6634 __densities_.push_back(__fw(__b_[__i]));
6639 #endif // _LIBCPP_CXX03_LANG
6641 template<class _RealType>
6642 template<class _UnaryOperation>
6643 piecewise_linear_distribution<_RealType>::param_type::param_type(
6644 size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
6645 : __b_(__nw == 0 ? 2 : __nw + 1)
6647 size_t __n = __b_.size() - 1;
6648 result_type __d = (__xmax - __xmin) / __n;
6649 __densities_.reserve(__b_.size());
6650 for (size_t __i = 0; __i < __n; ++__i)
6652 __b_[__i] = __xmin + __i * __d;
6653 __densities_.push_back(__fw(__b_[__i]));
6656 __densities_.push_back(__fw(__b_[__n]));
6660 template<class _RealType>
6661 template<class _URNG>
6663 piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
6665 typedef uniform_real_distribution<result_type> _Gen;
6666 result_type __u = _Gen()(__g);
6667 ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
6668 __u) - __p.__areas_.begin() - 1;
6669 __u -= __p.__areas_[__k];
6670 const result_type __dk = __p.__densities_[__k];
6671 const result_type __dk1 = __p.__densities_[__k+1];
6672 const result_type __deltad = __dk1 - __dk;
6673 const result_type __bk = __p.__b_[__k];
6675 return __u / __dk + __bk;
6676 const result_type __bk1 = __p.__b_[__k+1];
6677 const result_type __deltab = __bk1 - __bk;
6678 return (__bk * __dk1 - __bk1 * __dk +
6679 _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
6683 template <class _CharT, class _Traits, class _RT>
6684 basic_ostream<_CharT, _Traits>&
6685 operator<<(basic_ostream<_CharT, _Traits>& __os,
6686 const piecewise_linear_distribution<_RT>& __x)
6688 __save_flags<_CharT, _Traits> __lx(__os);
6689 __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
6690 ios_base::scientific);
6691 _CharT __sp = __os.widen(' ');
6693 size_t __n = __x.__p_.__b_.size();
6695 for (size_t __i = 0; __i < __n; ++__i)
6696 __os << __sp << __x.__p_.__b_[__i];
6697 __n = __x.__p_.__densities_.size();
6698 __os << __sp << __n;
6699 for (size_t __i = 0; __i < __n; ++__i)
6700 __os << __sp << __x.__p_.__densities_[__i];
6701 __n = __x.__p_.__areas_.size();
6702 __os << __sp << __n;
6703 for (size_t __i = 0; __i < __n; ++__i)
6704 __os << __sp << __x.__p_.__areas_[__i];
6708 template <class _CharT, class _Traits, class _RT>
6709 basic_istream<_CharT, _Traits>&
6710 operator>>(basic_istream<_CharT, _Traits>& __is,
6711 piecewise_linear_distribution<_RT>& __x)
6713 typedef piecewise_linear_distribution<_RT> _Eng;
6714 typedef typename _Eng::result_type result_type;
6715 __save_flags<_CharT, _Traits> __lx(__is);
6716 __is.flags(ios_base::dec | ios_base::skipws);
6719 vector<result_type> __b(__n);
6720 for (size_t __i = 0; __i < __n; ++__i)
6723 vector<result_type> __densities(__n);
6724 for (size_t __i = 0; __i < __n; ++__i)
6725 __is >> __densities[__i];
6727 vector<result_type> __areas(__n);
6728 for (size_t __i = 0; __i < __n; ++__i)
6729 __is >> __areas[__i];
6732 swap(__x.__p_.__b_, __b);
6733 swap(__x.__p_.__densities_, __densities);
6734 swap(__x.__p_.__areas_, __areas);
6739 _LIBCPP_END_NAMESPACE_STD
6743 #endif // _LIBCPP_RANDOM