From Jason Turner

[rand.dist.norm]

C++14 → C++17 6.4 KB 98 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/tmpnmzf1qzf/{from.md → to.md} +42 -48
tmp/tmpnmzf1qzf/{from.md → to.md} RENAMED
@@ -15,27 +15,26 @@ numbers x distributed according to the probability density function $$%
15
  \; \mbox{.}$$ The distribution parameters μ and σ are also known as this
16
  distribution’s *mean* and *standard deviation* .
17
 
18
  ``` cpp
19
  template<class RealType = double>
20
- class normal_distribution
21
- {
22
  public:
23
  // types
24
- typedef RealType result_type;
25
- typedef unspecified param_type;
26
 
27
  // constructors and reset functions
28
  explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
29
  explicit normal_distribution(const param_type& parm);
30
  void reset();
31
 
32
  // generating functions
33
- template<class URNG>
34
- result_type operator()(URNG& g);
35
- template<class URNG>
36
- result_type operator()(URNG& g, const param_type& parm);
37
 
38
  // property functions
39
  RealType mean() const;
40
  RealType stddev() const;
41
  param_type param() const;
@@ -83,27 +82,26 @@ $$%
83
  }
84
  \; \mbox{.}$$
85
 
86
  ``` cpp
87
  template<class RealType = double>
88
- class lognormal_distribution
89
- {
90
  public:
91
  // types
92
- typedef RealType result_type;
93
- typedef unspecified param_type;
94
 
95
  // constructor and reset functions
96
  explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
97
  explicit lognormal_distribution(const param_type& parm);
98
  void reset();
99
 
100
  // generating functions
101
- template<class URNG>
102
- result_type operator()(URNG& g);
103
- template<class URNG>
104
- result_type operator()(URNG& g, const param_type& parm);
105
 
106
  // property functions
107
  RealType m() const;
108
  RealType s() const;
109
  param_type param() const;
@@ -146,27 +144,26 @@ $$%
146
  {\Gamma(n/2) \cdot 2^{n/2}}
147
  \; \mbox{.}$$
148
 
149
  ``` cpp
150
  template<class RealType = double>
151
- class chi_squared_distribution
152
- {
153
  public:
154
  // types
155
- typedef RealType result_type;
156
- typedef unspecified param_type;
157
 
158
  // constructor and reset functions
159
  explicit chi_squared_distribution(RealType n = 1);
160
  explicit chi_squared_distribution(const param_type& parm);
161
  void reset();
162
 
163
  // generating functions
164
- template<class URNG>
165
- result_type operator()(URNG& g);
166
- template<class URNG>
167
- result_type operator()(URNG& g, const param_type& parm);
168
 
169
  // property functions
170
  RealType n() const;
171
  param_type param() const;
172
  void param(const param_type& parm);
@@ -199,27 +196,26 @@ numbers x distributed according to the probability density function $$%
199
  = \left( \pi b \left( 1 + \left( \frac{x-a}{b} \right)^2 \;\right)\right)^{-1}
200
  \; \mbox{.}$$
201
 
202
  ``` cpp
203
  template<class RealType = double>
204
- class cauchy_distribution
205
- {
206
  public:
207
  // types
208
- typedef RealType result_type;
209
- typedef unspecified param_type;
210
 
211
  // constructor and reset functions
212
  explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
213
  explicit cauchy_distribution(const param_type& parm);
214
  void reset();
215
 
216
  // generating functions
217
- template<class URNG>
218
- result_type operator()(URNG& g);
219
- template<class URNG>
220
- result_type operator()(URNG& g, const param_type& parm);
221
 
222
  // property functions
223
  RealType a() const;
224
  RealType b() const;
225
  param_type param() const;
@@ -268,27 +264,26 @@ $$%
268
  {\left( 1 + \frac{m x}{n} \right)}^{-(m+n)/2}
269
  \; \mbox{.}$$
270
 
271
  ``` cpp
272
  template<class RealType = double>
273
- class fisher_f_distribution
274
- {
275
  public:
276
  // types
277
- typedef RealType result_type;
278
- typedef unspecified param_type;
279
 
280
  // constructor and reset functions
281
  explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
282
  explicit fisher_f_distribution(const param_type& parm);
283
  void reset();
284
 
285
  // generating functions
286
- template<class URNG>
287
- result_type operator()(URNG& g);
288
- template<class URNG>
289
- result_type operator()(URNG& g, const param_type& parm);
290
 
291
  // property functions
292
  RealType m() const;
293
  RealType n() const;
294
  param_type param() const;
@@ -333,27 +328,26 @@ numbers x distributed according to the probability density function $$%
333
  \cdot \left( 1+\frac{x^2}{n} \right) ^ {-(n+1)/2}
334
  \; \mbox{.}$$
335
 
336
  ``` cpp
337
  template<class RealType = double>
338
- class student_t_distribution
339
- {
340
  public:
341
  // types
342
- typedef RealType result_type;
343
- typedef unspecified param_type;
344
 
345
  // constructor and reset functions
346
  explicit student_t_distribution(RealType n = 1);
347
  explicit student_t_distribution(const param_type& parm);
348
  void reset();
349
 
350
  // generating functions
351
- template<class URNG>
352
- result_type operator()(URNG& g);
353
- template<class URNG>
354
- result_type operator()(URNG& g, const param_type& parm);
355
 
356
  // property functions
357
  RealType n() const;
358
  param_type param() const;
359
  void param(const param_type& parm);
 
15
  \; \mbox{.}$$ The distribution parameters μ and σ are also known as this
16
  distribution’s *mean* and *standard deviation* .
17
 
18
  ``` cpp
19
  template<class RealType = double>
20
+ class normal_distribution {
 
21
  public:
22
  // types
23
+ using result_type = RealType;
24
+ using param_type = unspecified;
25
 
26
  // constructors and reset functions
27
  explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
28
  explicit normal_distribution(const param_type& parm);
29
  void reset();
30
 
31
  // generating functions
32
+ template<class URBG>
33
+ result_type operator()(URBG& g);
34
+ template<class URBG>
35
+ result_type operator()(URBG& g, const param_type& parm);
36
 
37
  // property functions
38
  RealType mean() const;
39
  RealType stddev() const;
40
  param_type param() const;
 
82
  }
83
  \; \mbox{.}$$
84
 
85
  ``` cpp
86
  template<class RealType = double>
87
+ class lognormal_distribution {
 
88
  public:
89
  // types
90
+ using result_type = RealType;
91
+ using param_type = unspecified;
92
 
93
  // constructor and reset functions
94
  explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
95
  explicit lognormal_distribution(const param_type& parm);
96
  void reset();
97
 
98
  // generating functions
99
+ template<class URBG>
100
+ result_type operator()(URBG& g);
101
+ template<class URBG>
102
+ result_type operator()(URBG& g, const param_type& parm);
103
 
104
  // property functions
105
  RealType m() const;
106
  RealType s() const;
107
  param_type param() const;
 
144
  {\Gamma(n/2) \cdot 2^{n/2}}
145
  \; \mbox{.}$$
146
 
147
  ``` cpp
148
  template<class RealType = double>
149
+ class chi_squared_distribution {
 
150
  public:
151
  // types
152
+ using result_type = RealType;
153
+ using param_type = unspecified;
154
 
155
  // constructor and reset functions
156
  explicit chi_squared_distribution(RealType n = 1);
157
  explicit chi_squared_distribution(const param_type& parm);
158
  void reset();
159
 
160
  // generating functions
161
+ template<class URBG>
162
+ result_type operator()(URBG& g);
163
+ template<class URBG>
164
+ result_type operator()(URBG& g, const param_type& parm);
165
 
166
  // property functions
167
  RealType n() const;
168
  param_type param() const;
169
  void param(const param_type& parm);
 
196
  = \left( \pi b \left( 1 + \left( \frac{x-a}{b} \right)^2 \;\right)\right)^{-1}
197
  \; \mbox{.}$$
198
 
199
  ``` cpp
200
  template<class RealType = double>
201
+ class cauchy_distribution {
 
202
  public:
203
  // types
204
+ using result_type = RealType;
205
+ using param_type = unspecified;
206
 
207
  // constructor and reset functions
208
  explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
209
  explicit cauchy_distribution(const param_type& parm);
210
  void reset();
211
 
212
  // generating functions
213
+ template<class URBG>
214
+ result_type operator()(URBG& g);
215
+ template<class URBG>
216
+ result_type operator()(URBG& g, const param_type& parm);
217
 
218
  // property functions
219
  RealType a() const;
220
  RealType b() const;
221
  param_type param() const;
 
264
  {\left( 1 + \frac{m x}{n} \right)}^{-(m+n)/2}
265
  \; \mbox{.}$$
266
 
267
  ``` cpp
268
  template<class RealType = double>
269
+ class fisher_f_distribution {
 
270
  public:
271
  // types
272
+ using result_type = RealType;
273
+ using param_type = unspecified;
274
 
275
  // constructor and reset functions
276
  explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
277
  explicit fisher_f_distribution(const param_type& parm);
278
  void reset();
279
 
280
  // generating functions
281
+ template<class URBG>
282
+ result_type operator()(URBG& g);
283
+ template<class URBG>
284
+ result_type operator()(URBG& g, const param_type& parm);
285
 
286
  // property functions
287
  RealType m() const;
288
  RealType n() const;
289
  param_type param() const;
 
328
  \cdot \left( 1+\frac{x^2}{n} \right) ^ {-(n+1)/2}
329
  \; \mbox{.}$$
330
 
331
  ``` cpp
332
  template<class RealType = double>
333
+ class student_t_distribution {
 
334
  public:
335
  // types
336
+ using result_type = RealType;
337
+ using param_type = unspecified;
338
 
339
  // constructor and reset functions
340
  explicit student_t_distribution(RealType n = 1);
341
  explicit student_t_distribution(const param_type& parm);
342
  void reset();
343
 
344
  // generating functions
345
+ template<class URBG>
346
+ result_type operator()(URBG& g);
347
+ template<class URBG>
348
+ result_type operator()(URBG& g, const param_type& parm);
349
 
350
  // property functions
351
  RealType n() const;
352
  param_type param() const;
353
  void param(const param_type& parm);