From Jason Turner

[rand.dist.pois]

C++14 → C++17 5.4 KB 82 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpmh2dn1cw/{from.md → to.md} +35 -39
tmp/tmpmh2dn1cw/{from.md → to.md} RENAMED
@@ -15,23 +15,23 @@ distribution’s *mean* .
15
  template<class IntType = int>
16
  class poisson_distribution
17
  {
18
  public:
19
  // types
20
- typedef IntType result_type;
21
- typedef unspecified param_type;
22
 
23
  // constructors and reset functions
24
  explicit poisson_distribution(double mean = 1.0);
25
  explicit poisson_distribution(const param_type& parm);
26
  void reset();
27
 
28
  // generating functions
29
- template<class URNG>
30
- result_type operator()(URNG& g);
31
- template<class URNG>
32
- result_type operator()(URNG& g, const param_type& parm);
33
 
34
  // property functions
35
  double mean() const;
36
  param_type param() const;
37
  void param(const param_type& parm);
@@ -65,27 +65,26 @@ $$%
65
  = \lambda e^{-\lambda x}
66
  \; \mbox{.}$$
67
 
68
  ``` cpp
69
  template<class RealType = double>
70
- class exponential_distribution
71
- {
72
  public:
73
  // types
74
- typedef RealType result_type;
75
- typedef unspecified param_type;
76
 
77
  // constructors and reset functions
78
  explicit exponential_distribution(RealType lambda = 1.0);
79
  explicit exponential_distribution(const param_type& parm);
80
  void reset();
81
 
82
  // generating functions
83
- template<class URNG>
84
- result_type operator()(URNG& g);
85
- template<class URNG>
86
- result_type operator()(URNG& g, const param_type& parm);
87
 
88
  // property functions
89
  RealType lambda() const;
90
  param_type param() const;
91
  void param(const param_type& parm);
@@ -98,11 +97,11 @@ public:
98
  explicit exponential_distribution(RealType lambda = 1.0);
99
  ```
100
 
101
  *Requires:* 0 < `lambda`.
102
 
103
- *Effects:* Constructs a `exponential_distribution` object; `lambda`
104
  corresponds to the parameter of the distribution.
105
 
106
  ``` cpp
107
  RealType lambda() const;
108
  ```
@@ -120,27 +119,26 @@ $$%
120
  \, \cdot \, x^{\, \alpha-1}
121
  \; \mbox{.}$$
122
 
123
  ``` cpp
124
  template<class RealType = double>
125
- class gamma_distribution
126
- {
127
  public:
128
  // types
129
- typedef RealType result_type;
130
- typedef unspecified param_type;
131
 
132
  // constructors and reset functions
133
  explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
134
  explicit gamma_distribution(const param_type& parm);
135
  void reset();
136
 
137
  // generating functions
138
- template<class URNG>
139
- result_type operator()(URNG& g);
140
- template<class URNG>
141
- result_type operator()(URNG& g, const param_type& parm);
142
 
143
  // property functions
144
  RealType alpha() const;
145
  RealType beta() const;
146
  param_type param() const;
@@ -184,27 +182,26 @@ $$%
184
  \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
185
  \; \mbox{.}$$
186
 
187
  ``` cpp
188
  template<class RealType = double>
189
- class weibull_distribution
190
- {
191
  public:
192
  // types
193
- typedef RealType result_type;
194
- typedef unspecified param_type;
195
 
196
  // constructor and reset functions
197
  explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
198
  explicit weibull_distribution(const param_type& parm);
199
  void reset();
200
 
201
  // generating functions
202
- template<class URNG>
203
- result_type operator()(URNG& g);
204
- template<class URNG>
205
- result_type operator()(URNG& g, const param_type& parm);
206
 
207
  // property functions
208
  RealType a() const;
209
  RealType b() const;
210
  param_type param() const;
@@ -249,27 +246,26 @@ function[^6] $$%
249
  \right)
250
  \; \mbox{.}$$
251
 
252
  ``` cpp
253
  template<class RealType = double>
254
- class extreme_value_distribution
255
- {
256
  public:
257
  // types
258
- typedef RealType result_type;
259
- typedef unspecified param_type;
260
 
261
  // constructor and reset functions
262
  explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
263
  explicit extreme_value_distribution(const param_type& parm);
264
  void reset();
265
 
266
  // generating functions
267
- template<class URNG>
268
- result_type operator()(URNG& g);
269
- template<class URNG>
270
- result_type operator()(URNG& g, const param_type& parm);
271
 
272
  // property functions
273
  RealType a() const;
274
  RealType b() const;
275
  param_type param() const;
 
15
  template<class IntType = int>
16
  class poisson_distribution
17
  {
18
  public:
19
  // types
20
+ using result_type = IntType;
21
+ using param_type = unspecified;
22
 
23
  // constructors and reset functions
24
  explicit poisson_distribution(double mean = 1.0);
25
  explicit poisson_distribution(const param_type& parm);
26
  void reset();
27
 
28
  // generating functions
29
+ template<class URBG>
30
+ result_type operator()(URBG& g);
31
+ template<class URBG>
32
+ result_type operator()(URBG& g, const param_type& parm);
33
 
34
  // property functions
35
  double mean() const;
36
  param_type param() const;
37
  void param(const param_type& parm);
 
65
  = \lambda e^{-\lambda x}
66
  \; \mbox{.}$$
67
 
68
  ``` cpp
69
  template<class RealType = double>
70
+ class exponential_distribution {
 
71
  public:
72
  // types
73
+ using result_type = RealType;
74
+ using param_type = unspecified;
75
 
76
  // constructors and reset functions
77
  explicit exponential_distribution(RealType lambda = 1.0);
78
  explicit exponential_distribution(const param_type& parm);
79
  void reset();
80
 
81
  // generating functions
82
+ template<class URBG>
83
+ result_type operator()(URBG& g);
84
+ template<class URBG>
85
+ result_type operator()(URBG& g, const param_type& parm);
86
 
87
  // property functions
88
  RealType lambda() const;
89
  param_type param() const;
90
  void param(const param_type& parm);
 
97
  explicit exponential_distribution(RealType lambda = 1.0);
98
  ```
99
 
100
  *Requires:* 0 < `lambda`.
101
 
102
+ *Effects:* Constructs an `exponential_distribution` object; `lambda`
103
  corresponds to the parameter of the distribution.
104
 
105
  ``` cpp
106
  RealType lambda() const;
107
  ```
 
119
  \, \cdot \, x^{\, \alpha-1}
120
  \; \mbox{.}$$
121
 
122
  ``` cpp
123
  template<class RealType = double>
124
+ class gamma_distribution {
 
125
  public:
126
  // types
127
+ using result_type = RealType;
128
+ using param_type = unspecified;
129
 
130
  // constructors and reset functions
131
  explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
132
  explicit gamma_distribution(const param_type& parm);
133
  void reset();
134
 
135
  // generating functions
136
+ template<class URBG>
137
+ result_type operator()(URBG& g);
138
+ template<class URBG>
139
+ result_type operator()(URBG& g, const param_type& parm);
140
 
141
  // property functions
142
  RealType alpha() const;
143
  RealType beta() const;
144
  param_type param() const;
 
182
  \cdot \, \exp\left( -\left(\frac{x}{b}\right)^a\right)
183
  \; \mbox{.}$$
184
 
185
  ``` cpp
186
  template<class RealType = double>
187
+ class weibull_distribution {
 
188
  public:
189
  // types
190
+ using result_type = RealType;
191
+ using param_type = unspecified;
192
 
193
  // constructor and reset functions
194
  explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0);
195
  explicit weibull_distribution(const param_type& parm);
196
  void reset();
197
 
198
  // generating functions
199
+ template<class URBG>
200
+ result_type operator()(URBG& g);
201
+ template<class URBG>
202
+ result_type operator()(URBG& g, const param_type& parm);
203
 
204
  // property functions
205
  RealType a() const;
206
  RealType b() const;
207
  param_type param() const;
 
246
  \right)
247
  \; \mbox{.}$$
248
 
249
  ``` cpp
250
  template<class RealType = double>
251
+ class extreme_value_distribution {
 
252
  public:
253
  // types
254
+ using result_type = RealType;
255
+ using param_type = unspecified;
256
 
257
  // constructor and reset functions
258
  explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
259
  explicit extreme_value_distribution(const param_type& parm);
260
  void reset();
261
 
262
  // generating functions
263
+ template<class URBG>
264
+ result_type operator()(URBG& g);
265
+ template<class URBG>
266
+ result_type operator()(URBG& g, const param_type& parm);
267
 
268
  // property functions
269
  RealType a() const;
270
  RealType b() const;
271
  param_type param() const;