master
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_RANDOM
11#define _LIBCPP_RANDOM
12
13/*
14 random synopsis
15
16#include <initializer_list>
17
18namespace std
19{
20// [rand.req.urng], uniform random bit generator requirements
21template<class G>
22concept uniform_random_bit_generator = see below; // C++20
23
24// Engines
25
26template <class UIntType, UIntType a, UIntType c, UIntType m>
27class linear_congruential_engine
28{
29public:
30 // types
31 typedef UIntType result_type;
32
33 // engine characteristics
34 static constexpr result_type multiplier = a;
35 static constexpr result_type increment = c;
36 static constexpr result_type modulus = m;
37 static constexpr result_type min() { return c == 0u ? 1u: 0u;}
38 static constexpr result_type max() { return m - 1u;}
39 static constexpr result_type default_seed = 1u;
40
41 // constructors and seeding functions
42 explicit linear_congruential_engine(result_type s = default_seed); // before C++20
43 linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20
44 explicit linear_congruential_engine(result_type s); // C++20
45 template<class Sseq> explicit linear_congruential_engine(Sseq& q);
46 void seed(result_type s = default_seed);
47 template<class Sseq> void seed(Sseq& q);
48
49 // generating functions
50 result_type operator()();
51 void discard(unsigned long long z);
52};
53
54template <class UIntType, UIntType a, UIntType c, UIntType m>
55bool
56operator==(const linear_congruential_engine<UIntType, a, c, m>& x,
57 const linear_congruential_engine<UIntType, a, c, m>& y);
58
59template <class UIntType, UIntType a, UIntType c, UIntType m>
60bool
61operator!=(const linear_congruential_engine<UIntType, a, c, m>& x,
62 const linear_congruential_engine<UIntType, a, c, m>& y);
63
64template <class charT, class traits,
65 class UIntType, UIntType a, UIntType c, UIntType m>
66basic_ostream<charT, traits>&
67operator<<(basic_ostream<charT, traits>& os,
68 const linear_congruential_engine<UIntType, a, c, m>& x);
69
70template <class charT, class traits,
71 class UIntType, UIntType a, UIntType c, UIntType m>
72basic_istream<charT, traits>&
73operator>>(basic_istream<charT, traits>& is,
74 linear_congruential_engine<UIntType, a, c, m>& x);
75
76template <class UIntType, size_t w, size_t n, size_t m, size_t r,
77 UIntType a, size_t u, UIntType d, size_t s,
78 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
79class mersenne_twister_engine
80{
81public:
82 // types
83 typedef UIntType result_type;
84
85 // engine characteristics
86 static constexpr size_t word_size = w;
87 static constexpr size_t state_size = n;
88 static constexpr size_t shift_size = m;
89 static constexpr size_t mask_bits = r;
90 static constexpr result_type xor_mask = a;
91 static constexpr size_t tempering_u = u;
92 static constexpr result_type tempering_d = d;
93 static constexpr size_t tempering_s = s;
94 static constexpr result_type tempering_b = b;
95 static constexpr size_t tempering_t = t;
96 static constexpr result_type tempering_c = c;
97 static constexpr size_t tempering_l = l;
98 static constexpr result_type initialization_multiplier = f;
99 static constexpr result_type min () { return 0; }
100 static constexpr result_type max() { return 2^w - 1; }
101 static constexpr result_type default_seed = 5489u;
102
103 // constructors and seeding functions
104 explicit mersenne_twister_engine(result_type s = default_seed); // before C++20
105 mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20
106 explicit mersenne_twister_engine(result_type s); // C++20
107 template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
108 void seed(result_type value = default_seed);
109 template<class Sseq> void seed(Sseq& q);
110
111 // generating functions
112 result_type operator()();
113 void discard(unsigned long long z);
114};
115
116template <class UIntType, size_t w, size_t n, size_t m, size_t r,
117 UIntType a, size_t u, UIntType d, size_t s,
118 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
119bool
120operator==(
121 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
122 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
123
124template <class UIntType, size_t w, size_t n, size_t m, size_t r,
125 UIntType a, size_t u, UIntType d, size_t s,
126 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
127bool
128operator!=(
129 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
130 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
131
132template <class charT, class traits,
133 class UIntType, size_t w, size_t n, size_t m, size_t r,
134 UIntType a, size_t u, UIntType d, size_t s,
135 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
136basic_ostream<charT, traits>&
137operator<<(basic_ostream<charT, traits>& os,
138 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
139
140template <class charT, class traits,
141 class UIntType, size_t w, size_t n, size_t m, size_t r,
142 UIntType a, size_t u, UIntType d, size_t s,
143 UIntType b, size_t t, UIntType c, size_t l, UIntType f>
144basic_istream<charT, traits>&
145operator>>(basic_istream<charT, traits>& is,
146 mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
147
148template<class UIntType, size_t w, size_t s, size_t r>
149class subtract_with_carry_engine
150{
151public:
152 // types
153 typedef UIntType result_type;
154
155 // engine characteristics
156 static constexpr size_t word_size = w;
157 static constexpr size_t short_lag = s;
158 static constexpr size_t long_lag = r;
159 static constexpr result_type min() { return 0; }
160 static constexpr result_type max() { return m-1; }
161 static constexpr result_type default_seed = 19780503u;
162
163 // constructors and seeding functions
164 explicit subtract_with_carry_engine(result_type value = default_seed); // before C++20
165 subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20
166 explicit subtract_with_carry_engine(result_type value); // C++20
167 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
168 void seed(result_type value = default_seed);
169 template<class Sseq> void seed(Sseq& q);
170
171 // generating functions
172 result_type operator()();
173 void discard(unsigned long long z);
174};
175
176template<class UIntType, size_t w, size_t s, size_t r>
177bool
178operator==(
179 const subtract_with_carry_engine<UIntType, w, s, r>& x,
180 const subtract_with_carry_engine<UIntType, w, s, r>& y);
181
182template<class UIntType, size_t w, size_t s, size_t r>
183bool
184operator!=(
185 const subtract_with_carry_engine<UIntType, w, s, r>& x,
186 const subtract_with_carry_engine<UIntType, w, s, r>& y);
187
188template <class charT, class traits,
189 class UIntType, size_t w, size_t s, size_t r>
190basic_ostream<charT, traits>&
191operator<<(basic_ostream<charT, traits>& os,
192 const subtract_with_carry_engine<UIntType, w, s, r>& x);
193
194template <class charT, class traits,
195 class UIntType, size_t w, size_t s, size_t r>
196basic_istream<charT, traits>&
197operator>>(basic_istream<charT, traits>& is,
198 subtract_with_carry_engine<UIntType, w, s, r>& x);
199
200template<class Engine, size_t p, size_t r>
201class discard_block_engine
202{
203public:
204 // types
205 typedef typename Engine::result_type result_type;
206
207 // engine characteristics
208 static constexpr size_t block_size = p;
209 static constexpr size_t used_block = r;
210 static constexpr result_type min() { return Engine::min(); }
211 static constexpr result_type max() { return Engine::max(); }
212
213 // constructors and seeding functions
214 discard_block_engine();
215 explicit discard_block_engine(const Engine& e);
216 explicit discard_block_engine(Engine&& e);
217 explicit discard_block_engine(result_type s);
218 template<class Sseq> explicit discard_block_engine(Sseq& q);
219 void seed();
220 void seed(result_type s);
221 template<class Sseq> void seed(Sseq& q);
222
223 // generating functions
224 result_type operator()();
225 void discard(unsigned long long z);
226
227 // property functions
228 const Engine& base() const noexcept;
229};
230
231template<class Engine, size_t p, size_t r>
232bool
233operator==(
234 const discard_block_engine<Engine, p, r>& x,
235 const discard_block_engine<Engine, p, r>& y);
236
237template<class Engine, size_t p, size_t r>
238bool
239operator!=(
240 const discard_block_engine<Engine, p, r>& x,
241 const discard_block_engine<Engine, p, r>& y);
242
243template <class charT, class traits,
244 class Engine, size_t p, size_t r>
245basic_ostream<charT, traits>&
246operator<<(basic_ostream<charT, traits>& os,
247 const discard_block_engine<Engine, p, r>& x);
248
249template <class charT, class traits,
250 class Engine, size_t p, size_t r>
251basic_istream<charT, traits>&
252operator>>(basic_istream<charT, traits>& is,
253 discard_block_engine<Engine, p, r>& x);
254
255template<class Engine, size_t w, class UIntType>
256class independent_bits_engine
257{
258public:
259 // types
260 typedef UIntType result_type;
261
262 // engine characteristics
263 static constexpr result_type min() { return 0; }
264 static constexpr result_type max() { return 2^w - 1; }
265
266 // constructors and seeding functions
267 independent_bits_engine();
268 explicit independent_bits_engine(const Engine& e);
269 explicit independent_bits_engine(Engine&& e);
270 explicit independent_bits_engine(result_type s);
271 template<class Sseq> explicit independent_bits_engine(Sseq& q);
272 void seed();
273 void seed(result_type s);
274 template<class Sseq> void seed(Sseq& q);
275
276 // generating functions
277 result_type operator()(); void discard(unsigned long long z);
278
279 // property functions
280 const Engine& base() const noexcept;
281};
282
283template<class Engine, size_t w, class UIntType>
284bool
285operator==(
286 const independent_bits_engine<Engine, w, UIntType>& x,
287 const independent_bits_engine<Engine, w, UIntType>& y);
288
289template<class Engine, size_t w, class UIntType>
290bool
291operator!=(
292 const independent_bits_engine<Engine, w, UIntType>& x,
293 const independent_bits_engine<Engine, w, UIntType>& y);
294
295template <class charT, class traits,
296 class Engine, size_t w, class UIntType>
297basic_ostream<charT, traits>&
298operator<<(basic_ostream<charT, traits>& os,
299 const independent_bits_engine<Engine, w, UIntType>& x);
300
301template <class charT, class traits,
302 class Engine, size_t w, class UIntType>
303basic_istream<charT, traits>&
304operator>>(basic_istream<charT, traits>& is,
305 independent_bits_engine<Engine, w, UIntType>& x);
306
307template<class Engine, size_t k>
308class shuffle_order_engine
309{
310public:
311 // types
312 typedef typename Engine::result_type result_type;
313
314 // engine characteristics
315 static constexpr size_t table_size = k;
316 static constexpr result_type min() { return Engine::min; }
317 static constexpr result_type max() { return Engine::max; }
318
319 // constructors and seeding functions
320 shuffle_order_engine();
321 explicit shuffle_order_engine(const Engine& e);
322 explicit shuffle_order_engine(Engine&& e);
323 explicit shuffle_order_engine(result_type s);
324 template<class Sseq> explicit shuffle_order_engine(Sseq& q);
325 void seed();
326 void seed(result_type s);
327 template<class Sseq> void seed(Sseq& q);
328
329 // generating functions
330 result_type operator()();
331 void discard(unsigned long long z);
332
333 // property functions
334 const Engine& base() const noexcept;
335};
336
337template<class Engine, size_t k>
338bool
339operator==(
340 const shuffle_order_engine<Engine, k>& x,
341 const shuffle_order_engine<Engine, k>& y);
342
343template<class Engine, size_t k>
344bool
345operator!=(
346 const shuffle_order_engine<Engine, k>& x,
347 const shuffle_order_engine<Engine, k>& y);
348
349template <class charT, class traits,
350 class Engine, size_t k>
351basic_ostream<charT, traits>&
352operator<<(basic_ostream<charT, traits>& os,
353 const shuffle_order_engine<Engine, k>& x);
354
355template <class charT, class traits,
356 class Engine, size_t k>
357basic_istream<charT, traits>&
358operator>>(basic_istream<charT, traits>& is,
359 shuffle_order_engine<Engine, k>& x);
360
361typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
362 minstd_rand0;
363typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
364 minstd_rand;
365typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
366 0x9908b0df,
367 11, 0xffffffff,
368 7, 0x9d2c5680,
369 15, 0xefc60000,
370 18, 1812433253> mt19937;
371typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
372 0xb5026f5aa96619e9,
373 29, 0x5555555555555555,
374 17, 0x71d67fffeda60000,
375 37, 0xfff7eee000000000,
376 43, 6364136223846793005> mt19937_64;
377typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
378typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
379typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
380typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
381typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
382typedef minstd_rand default_random_engine;
383
384// Generators
385
386class random_device
387{
388public:
389 // types
390 typedef unsigned int result_type;
391
392 // generator characteristics
393 static constexpr result_type min() { return numeric_limits<result_type>::min(); }
394 static constexpr result_type max() { return numeric_limits<result_type>::max(); }
395
396 // constructors
397 explicit random_device(const string& token = implementation-defined); // before C++20
398 random_device() : random_device(implementation-defined) {} // C++20
399 explicit random_device(const string& token); // C++20
400
401 // generating functions
402 result_type operator()();
403
404 // property functions
405 double entropy() const noexcept;
406
407 // no copy functions
408 random_device(const random_device& ) = delete;
409 void operator=(const random_device& ) = delete;
410};
411
412// Utilities
413
414class seed_seq
415{
416public:
417 // types
418 typedef uint_least32_t result_type;
419
420 // constructors
421 seed_seq();
422 template<class T>
423 seed_seq(initializer_list<T> il);
424 template<class InputIterator>
425 seed_seq(InputIterator begin, InputIterator end);
426
427 // generating functions
428 template<class RandomAccessIterator>
429 void generate(RandomAccessIterator begin, RandomAccessIterator end);
430
431 // property functions
432 size_t size() const;
433 template<class OutputIterator>
434 void param(OutputIterator dest) const;
435
436 // no copy functions
437 seed_seq(const seed_seq&) = delete;
438 void operator=(const seed_seq& ) = delete;
439};
440
441template<class RealType, size_t bits, class URNG>
442 RealType generate_canonical(URNG& g);
443
444// Distributions
445
446template<class IntType = int>
447class uniform_int_distribution
448{
449public:
450 // types
451 typedef IntType result_type;
452
453 class param_type
454 {
455 public:
456 typedef uniform_int_distribution distribution_type;
457
458 explicit param_type(IntType a = 0,
459 IntType b = numeric_limits<IntType>::max());
460
461 result_type a() const;
462 result_type b() const;
463
464 friend bool operator==(const param_type& x, const param_type& y);
465 friend bool operator!=(const param_type& x, const param_type& y);
466 };
467
468 // constructors and reset functions
469 explicit uniform_int_distribution(IntType a = 0,
470 IntType b = numeric_limits<IntType>::max()); // before C++20
471 uniform_int_distribution() : uniform_int_distribution(0) {} // C++20
472 explicit uniform_int_distribution(IntType a,
473 IntType b = numeric_limits<IntType>::max()); // C++20
474 explicit uniform_int_distribution(const param_type& parm);
475 void reset();
476
477 // generating functions
478 template<class URNG> result_type operator()(URNG& g);
479 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
480
481 // property functions
482 result_type a() const;
483 result_type b() const;
484
485 param_type param() const;
486 void param(const param_type& parm);
487
488 result_type min() const;
489 result_type max() const;
490
491 friend bool operator==(const uniform_int_distribution& x,
492 const uniform_int_distribution& y);
493 friend bool operator!=(const uniform_int_distribution& x,
494 const uniform_int_distribution& y);
495
496 template <class charT, class traits>
497 friend
498 basic_ostream<charT, traits>&
499 operator<<(basic_ostream<charT, traits>& os,
500 const uniform_int_distribution& x);
501
502 template <class charT, class traits>
503 friend
504 basic_istream<charT, traits>&
505 operator>>(basic_istream<charT, traits>& is,
506 uniform_int_distribution& x);
507};
508
509template<class RealType = double>
510class uniform_real_distribution
511{
512public:
513 // types
514 typedef RealType result_type;
515
516 class param_type
517 {
518 public:
519 typedef uniform_real_distribution distribution_type;
520
521 explicit param_type(RealType a = 0,
522 RealType b = 1);
523
524 result_type a() const;
525 result_type b() const;
526
527 friend bool operator==(const param_type& x, const param_type& y);
528 friend bool operator!=(const param_type& x, const param_type& y);
529 };
530
531 // constructors and reset functions
532 explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
533 uniform_real_distribution() : uniform_real_distribution(0.0) {} // C++20
534 explicit uniform_real_distribution(RealType a, RealType b = 1.0); // C++20
535 explicit uniform_real_distribution(const param_type& parm);
536 void reset();
537
538 // generating functions
539 template<class URNG> result_type operator()(URNG& g);
540 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
541
542 // property functions
543 result_type a() const;
544 result_type b() const;
545
546 param_type param() const;
547 void param(const param_type& parm);
548
549 result_type min() const;
550 result_type max() const;
551
552 friend bool operator==(const uniform_real_distribution& x,
553 const uniform_real_distribution& y);
554 friend bool operator!=(const uniform_real_distribution& x,
555 const uniform_real_distribution& y);
556
557 template <class charT, class traits>
558 friend
559 basic_ostream<charT, traits>&
560 operator<<(basic_ostream<charT, traits>& os,
561 const uniform_real_distribution& x);
562
563 template <class charT, class traits>
564 friend
565 basic_istream<charT, traits>&
566 operator>>(basic_istream<charT, traits>& is,
567 uniform_real_distribution& x);
568};
569
570class bernoulli_distribution
571{
572public:
573 // types
574 typedef bool result_type;
575
576 class param_type
577 {
578 public:
579 typedef bernoulli_distribution distribution_type;
580
581 explicit param_type(double p = 0.5);
582
583 double p() const;
584
585 friend bool operator==(const param_type& x, const param_type& y);
586 friend bool operator!=(const param_type& x, const param_type& y);
587 };
588
589 // constructors and reset functions
590 explicit bernoulli_distribution(double p = 0.5); // before C++20
591 bernoulli_distribution() : bernoulli_distribution(0.5) {} // C++20
592 explicit bernoulli_distribution(double p); // C++20
593 explicit bernoulli_distribution(const param_type& parm);
594 void reset();
595
596 // generating functions
597 template<class URNG> result_type operator()(URNG& g);
598 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
599
600 // property functions
601 double p() const;
602
603 param_type param() const;
604 void param(const param_type& parm);
605
606 result_type min() const;
607 result_type max() const;
608
609 friend bool operator==(const bernoulli_distribution& x,
610 const bernoulli_distribution& y);
611 friend bool operator!=(const bernoulli_distribution& x,
612 const bernoulli_distribution& y);
613
614 template <class charT, class traits>
615 friend
616 basic_ostream<charT, traits>&
617 operator<<(basic_ostream<charT, traits>& os,
618 const bernoulli_distribution& x);
619
620 template <class charT, class traits>
621 friend
622 basic_istream<charT, traits>&
623 operator>>(basic_istream<charT, traits>& is,
624 bernoulli_distribution& x);
625};
626
627template<class IntType = int>
628class binomial_distribution
629{
630public:
631 // types
632 typedef IntType result_type;
633
634 class param_type
635 {
636 public:
637 typedef binomial_distribution distribution_type;
638
639 explicit param_type(IntType t = 1, double p = 0.5);
640
641 IntType t() const;
642 double p() const;
643
644 friend bool operator==(const param_type& x, const param_type& y);
645 friend bool operator!=(const param_type& x, const param_type& y);
646 };
647
648 // constructors and reset functions
649 explicit binomial_distribution(IntType t = 1, double p = 0.5); // before C++20
650 binomial_distribution() : binomial_distribution(1) {} // C++20
651 explicit binomial_distribution(IntType t, double p = 0.5); // C++20
652 explicit binomial_distribution(const param_type& parm);
653 void reset();
654
655 // generating functions
656 template<class URNG> result_type operator()(URNG& g);
657 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
658
659 // property functions
660 IntType t() const;
661 double p() const;
662
663 param_type param() const;
664 void param(const param_type& parm);
665
666 result_type min() const;
667 result_type max() const;
668
669 friend bool operator==(const binomial_distribution& x,
670 const binomial_distribution& y);
671 friend bool operator!=(const binomial_distribution& x,
672 const binomial_distribution& y);
673
674 template <class charT, class traits>
675 friend
676 basic_ostream<charT, traits>&
677 operator<<(basic_ostream<charT, traits>& os,
678 const binomial_distribution& x);
679
680 template <class charT, class traits>
681 friend
682 basic_istream<charT, traits>&
683 operator>>(basic_istream<charT, traits>& is,
684 binomial_distribution& x);
685};
686
687template<class IntType = int>
688class geometric_distribution
689{
690public:
691 // types
692 typedef IntType result_type;
693
694 class param_type
695 {
696 public:
697 typedef geometric_distribution distribution_type;
698
699 explicit param_type(double p = 0.5);
700
701 double p() const;
702
703 friend bool operator==(const param_type& x, const param_type& y);
704 friend bool operator!=(const param_type& x, const param_type& y);
705 };
706
707 // constructors and reset functions
708 explicit geometric_distribution(double p = 0.5); // before C++20
709 geometric_distribution() : geometric_distribution(0.5) {} // C++20
710 explicit geometric_distribution(double p); // C++20
711 explicit geometric_distribution(const param_type& parm);
712 void reset();
713
714 // generating functions
715 template<class URNG> result_type operator()(URNG& g);
716 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
717
718 // property functions
719 double p() const;
720
721 param_type param() const;
722 void param(const param_type& parm);
723
724 result_type min() const;
725 result_type max() const;
726
727 friend bool operator==(const geometric_distribution& x,
728 const geometric_distribution& y);
729 friend bool operator!=(const geometric_distribution& x,
730 const geometric_distribution& y);
731
732 template <class charT, class traits>
733 friend
734 basic_ostream<charT, traits>&
735 operator<<(basic_ostream<charT, traits>& os,
736 const geometric_distribution& x);
737
738 template <class charT, class traits>
739 friend
740 basic_istream<charT, traits>&
741 operator>>(basic_istream<charT, traits>& is,
742 geometric_distribution& x);
743};
744
745template<class IntType = int>
746class negative_binomial_distribution
747{
748public:
749 // types
750 typedef IntType result_type;
751
752 class param_type
753 {
754 public:
755 typedef negative_binomial_distribution distribution_type;
756
757 explicit param_type(result_type k = 1, double p = 0.5);
758
759 result_type k() const;
760 double p() const;
761
762 friend bool operator==(const param_type& x, const param_type& y);
763 friend bool operator!=(const param_type& x, const param_type& y);
764 };
765
766 // constructor and reset functions
767 explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); // before C++20
768 negative_binomial_distribution() : negative_binomial_distribution(1) {} // C++20
769 explicit negative_binomial_distribution(IntType k, double p = 0.5); // C++20
770 explicit negative_binomial_distribution(const param_type& parm);
771 void reset();
772
773 // generating functions
774 template<class URNG> result_type operator()(URNG& g);
775 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
776
777 // property functions
778 result_type k() const;
779 double p() const;
780
781 param_type param() const;
782 void param(const param_type& parm);
783
784 result_type min() const;
785 result_type max() const;
786
787 friend bool operator==(const negative_binomial_distribution& x,
788 const negative_binomial_distribution& y);
789 friend bool operator!=(const negative_binomial_distribution& x,
790 const negative_binomial_distribution& y);
791
792 template <class charT, class traits>
793 friend
794 basic_ostream<charT, traits>&
795 operator<<(basic_ostream<charT, traits>& os,
796 const negative_binomial_distribution& x);
797
798 template <class charT, class traits>
799 friend
800 basic_istream<charT, traits>&
801 operator>>(basic_istream<charT, traits>& is,
802 negative_binomial_distribution& x);
803};
804
805template<class IntType = int>
806class poisson_distribution
807{
808public:
809 // types
810 typedef IntType result_type;
811
812 class param_type
813 {
814 public:
815 typedef poisson_distribution distribution_type;
816
817 explicit param_type(double mean = 1.0);
818
819 double mean() const;
820
821 friend bool operator==(const param_type& x, const param_type& y);
822 friend bool operator!=(const param_type& x, const param_type& y);
823 };
824
825 // constructors and reset functions
826 explicit poisson_distribution(double mean = 1.0); // before C++20
827 poisson_distribution() : poisson_distribution(1.0) {} // C++20
828 explicit poisson_distribution(double mean); // C++20
829 explicit poisson_distribution(const param_type& parm);
830 void reset();
831
832 // generating functions
833 template<class URNG> result_type operator()(URNG& g);
834 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
835
836 // property functions
837 double mean() const;
838
839 param_type param() const;
840 void param(const param_type& parm);
841
842 result_type min() const;
843 result_type max() const;
844
845 friend bool operator==(const poisson_distribution& x,
846 const poisson_distribution& y);
847 friend bool operator!=(const poisson_distribution& x,
848 const poisson_distribution& y);
849
850 template <class charT, class traits>
851 friend
852 basic_ostream<charT, traits>&
853 operator<<(basic_ostream<charT, traits>& os,
854 const poisson_distribution& x);
855
856 template <class charT, class traits>
857 friend
858 basic_istream<charT, traits>&
859 operator>>(basic_istream<charT, traits>& is,
860 poisson_distribution& x);
861};
862
863template<class RealType = double>
864class exponential_distribution
865{
866public:
867 // types
868 typedef RealType result_type;
869
870 class param_type
871 {
872 public:
873 typedef exponential_distribution distribution_type;
874
875 explicit param_type(result_type lambda = 1.0);
876
877 result_type lambda() const;
878
879 friend bool operator==(const param_type& x, const param_type& y);
880 friend bool operator!=(const param_type& x, const param_type& y);
881 };
882
883 // constructors and reset functions
884 explicit exponential_distribution(RealType lambda = 1.0); // before C++20
885 exponential_distribution() : exponential_distribution(1.0) {} // C++20
886 explicit exponential_distribution(RealType lambda); // C++20
887 explicit exponential_distribution(const param_type& parm);
888 void reset();
889
890 // generating functions
891 template<class URNG> result_type operator()(URNG& g);
892 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
893
894 // property functions
895 result_type lambda() const;
896
897 param_type param() const;
898 void param(const param_type& parm);
899
900 result_type min() const;
901 result_type max() const;
902
903 friend bool operator==(const exponential_distribution& x,
904 const exponential_distribution& y);
905 friend bool operator!=(const exponential_distribution& x,
906 const exponential_distribution& y);
907
908 template <class charT, class traits>
909 friend
910 basic_ostream<charT, traits>&
911 operator<<(basic_ostream<charT, traits>& os,
912 const exponential_distribution& x);
913
914 template <class charT, class traits>
915 friend
916 basic_istream<charT, traits>&
917 operator>>(basic_istream<charT, traits>& is,
918 exponential_distribution& x);
919};
920
921template<class RealType = double>
922class gamma_distribution
923{
924public:
925 // types
926 typedef RealType result_type;
927
928 class param_type
929 {
930 public:
931 typedef gamma_distribution distribution_type;
932
933 explicit param_type(result_type alpha = 1, result_type beta = 1);
934
935 result_type alpha() const;
936 result_type beta() const;
937
938 friend bool operator==(const param_type& x, const param_type& y);
939 friend bool operator!=(const param_type& x, const param_type& y);
940 };
941
942 // constructors and reset functions
943 explicit gamma_distribution(RealType alpha = 0.0, RealType beta = 1.0); // before C++20
944 gamma_distribution() : gamma_distribution(0.0) {} // C++20
945 explicit gamma_distribution(RealType alpha, RealType beta = 1.0); // C++20
946 explicit gamma_distribution(const param_type& parm);
947 void reset();
948
949 // generating functions
950 template<class URNG> result_type operator()(URNG& g);
951 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
952
953 // property functions
954 result_type alpha() const;
955 result_type beta() const;
956
957 param_type param() const;
958 void param(const param_type& parm);
959
960 result_type min() const;
961 result_type max() const;
962
963 friend bool operator==(const gamma_distribution& x,
964 const gamma_distribution& y);
965 friend bool operator!=(const gamma_distribution& x,
966 const gamma_distribution& y);
967
968 template <class charT, class traits>
969 friend
970 basic_ostream<charT, traits>&
971 operator<<(basic_ostream<charT, traits>& os,
972 const gamma_distribution& x);
973
974 template <class charT, class traits>
975 friend
976 basic_istream<charT, traits>&
977 operator>>(basic_istream<charT, traits>& is,
978 gamma_distribution& x);
979};
980
981template<class RealType = double>
982class weibull_distribution
983{
984public:
985 // types
986 typedef RealType result_type;
987
988 class param_type
989 {
990 public:
991 typedef weibull_distribution distribution_type;
992
993 explicit param_type(result_type alpha = 1, result_type beta = 1);
994
995 result_type a() const;
996 result_type b() const;
997
998 friend bool operator==(const param_type& x, const param_type& y);
999 friend bool operator!=(const param_type& x, const param_type& y);
1000 };
1001
1002 // constructor and reset functions
1003 explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); // before C++20
1004 weibull_distribution() : weibull_distribution(1.0) {} // C++20
1005 explicit weibull_distribution(RealType a, RealType b = 1.0); // C++20
1006 explicit weibull_distribution(const param_type& parm);
1007 void reset();
1008
1009 // generating functions
1010 template<class URNG> result_type operator()(URNG& g);
1011 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1012
1013 // property functions
1014 result_type a() const;
1015 result_type b() const;
1016
1017 param_type param() const;
1018 void param(const param_type& parm);
1019
1020 result_type min() const;
1021 result_type max() const;
1022
1023 friend bool operator==(const weibull_distribution& x,
1024 const weibull_distribution& y);
1025 friend bool operator!=(const weibull_distribution& x,
1026 const weibull_distribution& y);
1027
1028 template <class charT, class traits>
1029 friend
1030 basic_ostream<charT, traits>&
1031 operator<<(basic_ostream<charT, traits>& os,
1032 const weibull_distribution& x);
1033
1034 template <class charT, class traits>
1035 friend
1036 basic_istream<charT, traits>&
1037 operator>>(basic_istream<charT, traits>& is,
1038 weibull_distribution& x);
1039};
1040
1041template<class RealType = double>
1042class extreme_value_distribution
1043{
1044public:
1045 // types
1046 typedef RealType result_type;
1047
1048 class param_type
1049 {
1050 public:
1051 typedef extreme_value_distribution distribution_type;
1052
1053 explicit param_type(result_type a = 0, result_type b = 1);
1054
1055 result_type a() const;
1056 result_type b() const;
1057
1058 friend bool operator==(const param_type& x, const param_type& y);
1059 friend bool operator!=(const param_type& x, const param_type& y);
1060 };
1061
1062 // constructor and reset functions
1063 explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
1064 extreme_value_distribution() : extreme_value_distribution(0.0) {} // C++20
1065 explicit extreme_value_distribution(RealType a, RealType b = 1.0); // C++20
1066 explicit extreme_value_distribution(const param_type& parm);
1067 void reset();
1068
1069 // generating functions
1070 template<class URNG> result_type operator()(URNG& g);
1071 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1072
1073 // property functions
1074 result_type a() const;
1075 result_type b() const;
1076
1077 param_type param() const;
1078 void param(const param_type& parm);
1079
1080 result_type min() const;
1081 result_type max() const;
1082
1083 friend bool operator==(const extreme_value_distribution& x,
1084 const extreme_value_distribution& y);
1085 friend bool operator!=(const extreme_value_distribution& x,
1086 const extreme_value_distribution& y);
1087
1088 template <class charT, class traits>
1089 friend
1090 basic_ostream<charT, traits>&
1091 operator<<(basic_ostream<charT, traits>& os,
1092 const extreme_value_distribution& x);
1093
1094 template <class charT, class traits>
1095 friend
1096 basic_istream<charT, traits>&
1097 operator>>(basic_istream<charT, traits>& is,
1098 extreme_value_distribution& x);
1099};
1100
1101template<class RealType = double>
1102class normal_distribution
1103{
1104public:
1105 // types
1106 typedef RealType result_type;
1107
1108 class param_type
1109 {
1110 public:
1111 typedef normal_distribution distribution_type;
1112
1113 explicit param_type(result_type mean = 0, result_type stddev = 1);
1114
1115 result_type mean() const;
1116 result_type stddev() const;
1117
1118 friend bool operator==(const param_type& x, const param_type& y);
1119 friend bool operator!=(const param_type& x, const param_type& y);
1120 };
1121
1122 // constructors and reset functions
1123 explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
1124 normal_distribution() : normal_distribution(0.0) {} // C++20
1125 explicit normal_distribution(RealType mean, RealType stddev = 1.0); // C++20
1126 explicit normal_distribution(const param_type& parm);
1127 void reset();
1128
1129 // generating functions
1130 template<class URNG> result_type operator()(URNG& g);
1131 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1132
1133 // property functions
1134 result_type mean() const;
1135 result_type stddev() const;
1136
1137 param_type param() const;
1138 void param(const param_type& parm);
1139
1140 result_type min() const;
1141 result_type max() const;
1142
1143 friend bool operator==(const normal_distribution& x,
1144 const normal_distribution& y);
1145 friend bool operator!=(const normal_distribution& x,
1146 const normal_distribution& y);
1147
1148 template <class charT, class traits>
1149 friend
1150 basic_ostream<charT, traits>&
1151 operator<<(basic_ostream<charT, traits>& os,
1152 const normal_distribution& x);
1153
1154 template <class charT, class traits>
1155 friend
1156 basic_istream<charT, traits>&
1157 operator>>(basic_istream<charT, traits>& is,
1158 normal_distribution& x);
1159};
1160
1161template<class RealType = double>
1162class lognormal_distribution
1163{
1164public:
1165 // types
1166 typedef RealType result_type;
1167
1168 class param_type
1169 {
1170 public:
1171 typedef lognormal_distribution distribution_type;
1172
1173 explicit param_type(result_type m = 0, result_type s = 1);
1174
1175 result_type m() const;
1176 result_type s() const;
1177
1178 friend bool operator==(const param_type& x, const param_type& y);
1179 friend bool operator!=(const param_type& x, const param_type& y);
1180 };
1181
1182 // constructor and reset functions
1183 explicit lognormal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20
1184 lognormal_distribution() : lognormal_distribution(0.0) {} // C++20
1185 explicit lognormal_distribution(RealType mean, RealType stddev = 1.0); // C++20
1186 explicit lognormal_distribution(const param_type& parm);
1187 void reset();
1188
1189 // generating functions
1190 template<class URNG> result_type operator()(URNG& g);
1191 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1192
1193 // property functions
1194 result_type m() const;
1195 result_type s() const;
1196
1197 param_type param() const;
1198 void param(const param_type& parm);
1199
1200 result_type min() const;
1201 result_type max() const;
1202
1203 friend bool operator==(const lognormal_distribution& x,
1204 const lognormal_distribution& y);
1205 friend bool operator!=(const lognormal_distribution& x,
1206 const lognormal_distribution& y);
1207
1208 template <class charT, class traits>
1209 friend
1210 basic_ostream<charT, traits>&
1211 operator<<(basic_ostream<charT, traits>& os,
1212 const lognormal_distribution& x);
1213
1214 template <class charT, class traits>
1215 friend
1216 basic_istream<charT, traits>&
1217 operator>>(basic_istream<charT, traits>& is,
1218 lognormal_distribution& x);
1219};
1220
1221template<class RealType = double>
1222class chi_squared_distribution
1223{
1224public:
1225 // types
1226 typedef RealType result_type;
1227
1228 class param_type
1229 {
1230 public:
1231 typedef chi_squared_distribution distribution_type;
1232
1233 explicit param_type(result_type n = 1);
1234
1235 result_type n() const;
1236
1237 friend bool operator==(const param_type& x, const param_type& y);
1238 friend bool operator!=(const param_type& x, const param_type& y);
1239 };
1240
1241 // constructor and reset functions
1242 explicit chi_squared_distribution(RealType n = 1.0); // before C++20
1243 chi_squared_distribution() : chi_squared_distribution(1.0) {} // C++20
1244 explicit chi_squared_distribution(RealType n); // C++20
1245 explicit chi_squared_distribution(const param_type& parm);
1246 void reset();
1247
1248 // generating functions
1249 template<class URNG> result_type operator()(URNG& g);
1250 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1251
1252 // property functions
1253 result_type n() const;
1254
1255 param_type param() const;
1256 void param(const param_type& parm);
1257
1258 result_type min() const;
1259 result_type max() const;
1260
1261 friend bool operator==(const chi_squared_distribution& x,
1262 const chi_squared_distribution& y);
1263 friend bool operator!=(const chi_squared_distribution& x,
1264 const chi_squared_distribution& y);
1265
1266 template <class charT, class traits>
1267 friend
1268 basic_ostream<charT, traits>&
1269 operator<<(basic_ostream<charT, traits>& os,
1270 const chi_squared_distribution& x);
1271
1272 template <class charT, class traits>
1273 friend
1274 basic_istream<charT, traits>&
1275 operator>>(basic_istream<charT, traits>& is,
1276 chi_squared_distribution& x);
1277};
1278
1279template<class RealType = double>
1280class cauchy_distribution
1281{
1282public:
1283 // types
1284 typedef RealType result_type;
1285
1286 class param_type
1287 {
1288 public:
1289 typedef cauchy_distribution distribution_type;
1290
1291 explicit param_type(result_type a = 0, result_type b = 1);
1292
1293 result_type a() const;
1294 result_type b() const;
1295
1296 friend bool operator==(const param_type& x, const param_type& y);
1297 friend bool operator!=(const param_type& x, const param_type& y);
1298 };
1299
1300 // constructor and reset functions
1301 explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20
1302 cauchy_distribution() : cauchy_distribution(0.0) {} // C++20
1303 explicit cauchy_distribution(RealType a, RealType b = 1.0); // C++20
1304 explicit cauchy_distribution(const param_type& parm);
1305 void reset();
1306
1307 // generating functions
1308 template<class URNG> result_type operator()(URNG& g);
1309 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1310
1311 // property functions
1312 result_type a() const;
1313 result_type b() const;
1314
1315 param_type param() const;
1316 void param(const param_type& parm);
1317
1318 result_type min() const;
1319 result_type max() const;
1320
1321 friend bool operator==(const cauchy_distribution& x,
1322 const cauchy_distribution& y);
1323 friend bool operator!=(const cauchy_distribution& x,
1324 const cauchy_distribution& y);
1325
1326 template <class charT, class traits>
1327 friend
1328 basic_ostream<charT, traits>&
1329 operator<<(basic_ostream<charT, traits>& os,
1330 const cauchy_distribution& x);
1331
1332 template <class charT, class traits>
1333 friend
1334 basic_istream<charT, traits>&
1335 operator>>(basic_istream<charT, traits>& is,
1336 cauchy_distribution& x);
1337};
1338
1339template<class RealType = double>
1340class fisher_f_distribution
1341{
1342public:
1343 // types
1344 typedef RealType result_type;
1345
1346 class param_type
1347 {
1348 public:
1349 typedef fisher_f_distribution distribution_type;
1350
1351 explicit param_type(result_type m = 1, result_type n = 1);
1352
1353 result_type m() const;
1354 result_type n() const;
1355
1356 friend bool operator==(const param_type& x, const param_type& y);
1357 friend bool operator!=(const param_type& x, const param_type& y);
1358 };
1359
1360 // constructor and reset functions
1361 explicit fisher_f_distribution(RealType m = 1.0, RealType n = 1.0); // before C++20
1362 fisher_f_distribution() : fisher_f_distribution(1.0) {} // C++20
1363 explicit fisher_f_distribution(RealType m, RealType n = 1.0); // C++20
1364 explicit fisher_f_distribution(const param_type& parm);
1365 void reset();
1366
1367 // generating functions
1368 template<class URNG> result_type operator()(URNG& g);
1369 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1370
1371 // property functions
1372 result_type m() const;
1373 result_type n() const;
1374
1375 param_type param() const;
1376 void param(const param_type& parm);
1377
1378 result_type min() const;
1379 result_type max() const;
1380
1381 friend bool operator==(const fisher_f_distribution& x,
1382 const fisher_f_distribution& y);
1383 friend bool operator!=(const fisher_f_distribution& x,
1384 const fisher_f_distribution& y);
1385
1386 template <class charT, class traits>
1387 friend
1388 basic_ostream<charT, traits>&
1389 operator<<(basic_ostream<charT, traits>& os,
1390 const fisher_f_distribution& x);
1391
1392 template <class charT, class traits>
1393 friend
1394 basic_istream<charT, traits>&
1395 operator>>(basic_istream<charT, traits>& is,
1396 fisher_f_distribution& x);
1397};
1398
1399template<class RealType = double>
1400class student_t_distribution
1401{
1402public:
1403 // types
1404 typedef RealType result_type;
1405
1406 class param_type
1407 {
1408 public:
1409 typedef student_t_distribution distribution_type;
1410
1411 explicit param_type(result_type n = 1);
1412
1413 result_type n() const;
1414
1415 friend bool operator==(const param_type& x, const param_type& y);
1416 friend bool operator!=(const param_type& x, const param_type& y);
1417 };
1418
1419 // constructor and reset functions
1420 explicit student_t_distribution(RealType n = 1.0); // before C++20
1421 student_t_distribution() : student_t_distribution(1.0) {} // C++20
1422 explicit student_t_distribution(RealType n); // C++20
1423 explicit student_t_distribution(const param_type& parm);
1424 void reset();
1425
1426 // generating functions
1427 template<class URNG> result_type operator()(URNG& g);
1428 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1429
1430 // property functions
1431 result_type n() const;
1432
1433 param_type param() const;
1434 void param(const param_type& parm);
1435
1436 result_type min() const;
1437 result_type max() const;
1438
1439 friend bool operator==(const student_t_distribution& x,
1440 const student_t_distribution& y);
1441 friend bool operator!=(const student_t_distribution& x,
1442 const student_t_distribution& y);
1443
1444 template <class charT, class traits>
1445 friend
1446 basic_ostream<charT, traits>&
1447 operator<<(basic_ostream<charT, traits>& os,
1448 const student_t_distribution& x);
1449
1450 template <class charT, class traits>
1451 friend
1452 basic_istream<charT, traits>&
1453 operator>>(basic_istream<charT, traits>& is,
1454 student_t_distribution& x);
1455};
1456
1457template<class IntType = int>
1458class discrete_distribution
1459{
1460public:
1461 // types
1462 typedef IntType result_type;
1463
1464 class param_type
1465 {
1466 public:
1467 typedef discrete_distribution distribution_type;
1468
1469 param_type();
1470 template<class InputIterator>
1471 param_type(InputIterator firstW, InputIterator lastW);
1472 param_type(initializer_list<double> wl);
1473 template<class UnaryOperation>
1474 param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);
1475
1476 vector<double> probabilities() const;
1477
1478 friend bool operator==(const param_type& x, const param_type& y);
1479 friend bool operator!=(const param_type& x, const param_type& y);
1480 };
1481
1482 // constructor and reset functions
1483 discrete_distribution();
1484 template<class InputIterator>
1485 discrete_distribution(InputIterator firstW, InputIterator lastW);
1486 discrete_distribution(initializer_list<double> wl);
1487 template<class UnaryOperation>
1488 discrete_distribution(size_t nw, double xmin, double xmax,
1489 UnaryOperation fw);
1490 explicit discrete_distribution(const param_type& parm);
1491 void reset();
1492
1493 // generating functions
1494 template<class URNG> result_type operator()(URNG& g);
1495 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1496
1497 // property functions
1498 vector<double> probabilities() const;
1499
1500 param_type param() const;
1501 void param(const param_type& parm);
1502
1503 result_type min() const;
1504 result_type max() const;
1505
1506 friend bool operator==(const discrete_distribution& x,
1507 const discrete_distribution& y);
1508 friend bool operator!=(const discrete_distribution& x,
1509 const discrete_distribution& y);
1510
1511 template <class charT, class traits>
1512 friend
1513 basic_ostream<charT, traits>&
1514 operator<<(basic_ostream<charT, traits>& os,
1515 const discrete_distribution& x);
1516
1517 template <class charT, class traits>
1518 friend
1519 basic_istream<charT, traits>&
1520 operator>>(basic_istream<charT, traits>& is,
1521 discrete_distribution& x);
1522};
1523
1524template<class RealType = double>
1525class piecewise_constant_distribution
1526{
1527 // types
1528 typedef RealType result_type;
1529
1530 class param_type
1531 {
1532 public:
1533 typedef piecewise_constant_distribution distribution_type;
1534
1535 param_type();
1536 template<class InputIteratorB, class InputIteratorW>
1537 param_type(InputIteratorB firstB, InputIteratorB lastB,
1538 InputIteratorW firstW);
1539 template<class UnaryOperation>
1540 param_type(initializer_list<result_type> bl, UnaryOperation fw);
1541 template<class UnaryOperation>
1542 param_type(size_t nw, result_type xmin, result_type xmax,
1543 UnaryOperation fw);
1544
1545 vector<result_type> intervals() const;
1546 vector<result_type> densities() const;
1547
1548 friend bool operator==(const param_type& x, const param_type& y);
1549 friend bool operator!=(const param_type& x, const param_type& y);
1550 };
1551
1552 // constructor and reset functions
1553 piecewise_constant_distribution();
1554 template<class InputIteratorB, class InputIteratorW>
1555 piecewise_constant_distribution(InputIteratorB firstB,
1556 InputIteratorB lastB,
1557 InputIteratorW firstW);
1558 template<class UnaryOperation>
1559 piecewise_constant_distribution(initializer_list<result_type> bl,
1560 UnaryOperation fw);
1561 template<class UnaryOperation>
1562 piecewise_constant_distribution(size_t nw, result_type xmin,
1563 result_type xmax, UnaryOperation fw);
1564 explicit piecewise_constant_distribution(const param_type& parm);
1565 void reset();
1566
1567 // generating functions
1568 template<class URNG> result_type operator()(URNG& g);
1569 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1570
1571 // property functions
1572 vector<result_type> intervals() const;
1573 vector<result_type> densities() const;
1574
1575 param_type param() const;
1576 void param(const param_type& parm);
1577
1578 result_type min() const;
1579 result_type max() const;
1580
1581 friend bool operator==(const piecewise_constant_distribution& x,
1582 const piecewise_constant_distribution& y);
1583 friend bool operator!=(const piecewise_constant_distribution& x,
1584 const piecewise_constant_distribution& y);
1585
1586 template <class charT, class traits>
1587 friend
1588 basic_ostream<charT, traits>&
1589 operator<<(basic_ostream<charT, traits>& os,
1590 const piecewise_constant_distribution& x);
1591
1592 template <class charT, class traits>
1593 friend
1594 basic_istream<charT, traits>&
1595 operator>>(basic_istream<charT, traits>& is,
1596 piecewise_constant_distribution& x);
1597};
1598
1599template<class RealType = double>
1600class piecewise_linear_distribution
1601{
1602 // types
1603 typedef RealType result_type;
1604
1605 class param_type
1606 {
1607 public:
1608 typedef piecewise_linear_distribution distribution_type;
1609
1610 param_type();
1611 template<class InputIteratorB, class InputIteratorW>
1612 param_type(InputIteratorB firstB, InputIteratorB lastB,
1613 InputIteratorW firstW);
1614 template<class UnaryOperation>
1615 param_type(initializer_list<result_type> bl, UnaryOperation fw);
1616 template<class UnaryOperation>
1617 param_type(size_t nw, result_type xmin, result_type xmax,
1618 UnaryOperation fw);
1619
1620 vector<result_type> intervals() const;
1621 vector<result_type> densities() const;
1622
1623 friend bool operator==(const param_type& x, const param_type& y);
1624 friend bool operator!=(const param_type& x, const param_type& y);
1625 };
1626
1627 // constructor and reset functions
1628 piecewise_linear_distribution();
1629 template<class InputIteratorB, class InputIteratorW>
1630 piecewise_linear_distribution(InputIteratorB firstB,
1631 InputIteratorB lastB,
1632 InputIteratorW firstW);
1633
1634 template<class UnaryOperation>
1635 piecewise_linear_distribution(initializer_list<result_type> bl,
1636 UnaryOperation fw);
1637
1638 template<class UnaryOperation>
1639 piecewise_linear_distribution(size_t nw, result_type xmin,
1640 result_type xmax, UnaryOperation fw);
1641
1642 explicit piecewise_linear_distribution(const param_type& parm);
1643 void reset();
1644
1645 // generating functions
1646 template<class URNG> result_type operator()(URNG& g);
1647 template<class URNG> result_type operator()(URNG& g, const param_type& parm);
1648
1649 // property functions
1650 vector<result_type> intervals() const;
1651 vector<result_type> densities() const;
1652
1653 param_type param() const;
1654 void param(const param_type& parm);
1655
1656 result_type min() const;
1657 result_type max() const;
1658
1659 friend bool operator==(const piecewise_linear_distribution& x,
1660 const piecewise_linear_distribution& y);
1661 friend bool operator!=(const piecewise_linear_distribution& x,
1662 const piecewise_linear_distribution& y);
1663
1664 template <class charT, class traits>
1665 friend
1666 basic_ostream<charT, traits>&
1667 operator<<(basic_ostream<charT, traits>& os,
1668 const piecewise_linear_distribution& x);
1669
1670 template <class charT, class traits>
1671 friend
1672 basic_istream<charT, traits>&
1673 operator>>(basic_istream<charT, traits>& is,
1674 piecewise_linear_distribution& x);
1675};
1676
1677} // std
1678*/
1679
1680#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1681# include <__cxx03/random>
1682#else
1683# include <__config>
1684# include <__random/bernoulli_distribution.h>
1685# include <__random/binomial_distribution.h>
1686# include <__random/cauchy_distribution.h>
1687# include <__random/chi_squared_distribution.h>
1688# include <__random/default_random_engine.h>
1689# include <__random/discard_block_engine.h>
1690# include <__random/discrete_distribution.h>
1691# include <__random/exponential_distribution.h>
1692# include <__random/extreme_value_distribution.h>
1693# include <__random/fisher_f_distribution.h>
1694# include <__random/gamma_distribution.h>
1695# include <__random/generate_canonical.h>
1696# include <__random/geometric_distribution.h>
1697# include <__random/independent_bits_engine.h>
1698# include <__random/is_seed_sequence.h>
1699# include <__random/knuth_b.h>
1700# include <__random/linear_congruential_engine.h>
1701# include <__random/lognormal_distribution.h>
1702# include <__random/mersenne_twister_engine.h>
1703# include <__random/negative_binomial_distribution.h>
1704# include <__random/normal_distribution.h>
1705# include <__random/piecewise_constant_distribution.h>
1706# include <__random/piecewise_linear_distribution.h>
1707# include <__random/poisson_distribution.h>
1708# include <__random/random_device.h>
1709# include <__random/ranlux.h>
1710# include <__random/seed_seq.h>
1711# include <__random/shuffle_order_engine.h>
1712# include <__random/student_t_distribution.h>
1713# include <__random/subtract_with_carry_engine.h>
1714# include <__random/uniform_int_distribution.h>
1715# include <__random/uniform_random_bit_generator.h>
1716# include <__random/uniform_real_distribution.h>
1717# include <__random/weibull_distribution.h>
1718# include <version>
1719
1720// standard-mandated includes
1721
1722// [rand.synopsis]
1723# include <initializer_list>
1724
1725# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1726# pragma GCC system_header
1727# endif
1728
1729# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1730# include <algorithm>
1731# include <climits>
1732# include <cmath>
1733# include <concepts>
1734# include <cstddef>
1735# include <cstdint>
1736# include <cstdlib>
1737# include <iosfwd>
1738# include <limits>
1739# include <numeric>
1740# include <string>
1741# include <type_traits>
1742# include <vector>
1743# endif
1744#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1745
1746#endif // _LIBCPP_RANDOM