1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // <random>
11
12 // template<class RealType = double>
13 // class uniform_real_distribution
14
15 // template<class _URNG> result_type operator()(_URNG& g);
16
17 #include <random>
18 #include <cassert>
19 #include <vector>
20 #include <numeric>
21
22 template <class T>
23 inline
24 T
sqr(T x)25 sqr(T x)
26 {
27 return x * x;
28 }
29
main()30 int main()
31 {
32 {
33 typedef std::uniform_real_distribution<> D;
34 typedef std::minstd_rand0 G;
35 G g;
36 D d;
37 const int N = 100000;
38 std::vector<D::result_type> u;
39 for (int i = 0; i < N; ++i)
40 {
41 D::result_type v = d(g);
42 assert(d.a() <= v && v < d.b());
43 u.push_back(v);
44 }
45 D::result_type mean = std::accumulate(u.begin(), u.end(),
46 D::result_type(0)) / u.size();
47 D::result_type var = 0;
48 D::result_type skew = 0;
49 D::result_type kurtosis = 0;
50 for (int i = 0; i < u.size(); ++i)
51 {
52 D::result_type d = (u[i] - mean);
53 D::result_type d2 = sqr(d);
54 var += d2;
55 skew += d * d2;
56 kurtosis += d2 * d2;
57 }
58 var /= u.size();
59 D::result_type dev = std::sqrt(var);
60 skew /= u.size() * dev * var;
61 kurtosis /= u.size() * var * var;
62 kurtosis -= 3;
63 D::result_type x_mean = (d.a() + d.b()) / 2;
64 D::result_type x_var = sqr(d.b() - d.a()) / 12;
65 D::result_type x_skew = 0;
66 D::result_type x_kurtosis = -6./5;
67 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
68 assert(std::abs((var - x_var) / x_var) < 0.01);
69 assert(std::abs(skew - x_skew) < 0.01);
70 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
71 }
72 {
73 typedef std::uniform_real_distribution<> D;
74 typedef std::minstd_rand G;
75 G g;
76 D d;
77 const int N = 100000;
78 std::vector<D::result_type> u;
79 for (int i = 0; i < N; ++i)
80 {
81 D::result_type v = d(g);
82 assert(d.a() <= v && v < d.b());
83 u.push_back(v);
84 }
85 D::result_type mean = std::accumulate(u.begin(), u.end(),
86 D::result_type(0)) / u.size();
87 D::result_type var = 0;
88 D::result_type skew = 0;
89 D::result_type kurtosis = 0;
90 for (int i = 0; i < u.size(); ++i)
91 {
92 D::result_type d = (u[i] - mean);
93 D::result_type d2 = sqr(d);
94 var += d2;
95 skew += d * d2;
96 kurtosis += d2 * d2;
97 }
98 var /= u.size();
99 D::result_type dev = std::sqrt(var);
100 skew /= u.size() * dev * var;
101 kurtosis /= u.size() * var * var;
102 kurtosis -= 3;
103 D::result_type x_mean = (d.a() + d.b()) / 2;
104 D::result_type x_var = sqr(d.b() - d.a()) / 12;
105 D::result_type x_skew = 0;
106 D::result_type x_kurtosis = -6./5;
107 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
108 assert(std::abs((var - x_var) / x_var) < 0.01);
109 assert(std::abs(skew - x_skew) < 0.01);
110 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
111 }
112 {
113 typedef std::uniform_real_distribution<> D;
114 typedef std::mt19937 G;
115 G g;
116 D d;
117 const int N = 100000;
118 std::vector<D::result_type> u;
119 for (int i = 0; i < N; ++i)
120 {
121 D::result_type v = d(g);
122 assert(d.a() <= v && v < d.b());
123 u.push_back(v);
124 }
125 D::result_type mean = std::accumulate(u.begin(), u.end(),
126 D::result_type(0)) / u.size();
127 D::result_type var = 0;
128 D::result_type skew = 0;
129 D::result_type kurtosis = 0;
130 for (int i = 0; i < u.size(); ++i)
131 {
132 D::result_type d = (u[i] - mean);
133 D::result_type d2 = sqr(d);
134 var += d2;
135 skew += d * d2;
136 kurtosis += d2 * d2;
137 }
138 var /= u.size();
139 D::result_type dev = std::sqrt(var);
140 skew /= u.size() * dev * var;
141 kurtosis /= u.size() * var * var;
142 kurtosis -= 3;
143 D::result_type x_mean = (d.a() + d.b()) / 2;
144 D::result_type x_var = sqr(d.b() - d.a()) / 12;
145 D::result_type x_skew = 0;
146 D::result_type x_kurtosis = -6./5;
147 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
148 assert(std::abs((var - x_var) / x_var) < 0.01);
149 assert(std::abs(skew - x_skew) < 0.01);
150 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
151 }
152 {
153 typedef std::uniform_real_distribution<> D;
154 typedef std::mt19937_64 G;
155 G g;
156 D d;
157 const int N = 100000;
158 std::vector<D::result_type> u;
159 for (int i = 0; i < N; ++i)
160 {
161 D::result_type v = d(g);
162 assert(d.a() <= v && v < d.b());
163 u.push_back(v);
164 }
165 D::result_type mean = std::accumulate(u.begin(), u.end(),
166 D::result_type(0)) / u.size();
167 D::result_type var = 0;
168 D::result_type skew = 0;
169 D::result_type kurtosis = 0;
170 for (int i = 0; i < u.size(); ++i)
171 {
172 D::result_type d = (u[i] - mean);
173 D::result_type d2 = sqr(d);
174 var += d2;
175 skew += d * d2;
176 kurtosis += d2 * d2;
177 }
178 var /= u.size();
179 D::result_type dev = std::sqrt(var);
180 skew /= u.size() * dev * var;
181 kurtosis /= u.size() * var * var;
182 kurtosis -= 3;
183 D::result_type x_mean = (d.a() + d.b()) / 2;
184 D::result_type x_var = sqr(d.b() - d.a()) / 12;
185 D::result_type x_skew = 0;
186 D::result_type x_kurtosis = -6./5;
187 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
188 assert(std::abs((var - x_var) / x_var) < 0.01);
189 assert(std::abs(skew - x_skew) < 0.01);
190 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
191 }
192 {
193 typedef std::uniform_real_distribution<> D;
194 typedef std::ranlux24_base G;
195 G g;
196 D d;
197 const int N = 100000;
198 std::vector<D::result_type> u;
199 for (int i = 0; i < N; ++i)
200 {
201 D::result_type v = d(g);
202 assert(d.a() <= v && v < d.b());
203 u.push_back(v);
204 }
205 D::result_type mean = std::accumulate(u.begin(), u.end(),
206 D::result_type(0)) / u.size();
207 D::result_type var = 0;
208 D::result_type skew = 0;
209 D::result_type kurtosis = 0;
210 for (int i = 0; i < u.size(); ++i)
211 {
212 D::result_type d = (u[i] - mean);
213 D::result_type d2 = sqr(d);
214 var += d2;
215 skew += d * d2;
216 kurtosis += d2 * d2;
217 }
218 var /= u.size();
219 D::result_type dev = std::sqrt(var);
220 skew /= u.size() * dev * var;
221 kurtosis /= u.size() * var * var;
222 kurtosis -= 3;
223 D::result_type x_mean = (d.a() + d.b()) / 2;
224 D::result_type x_var = sqr(d.b() - d.a()) / 12;
225 D::result_type x_skew = 0;
226 D::result_type x_kurtosis = -6./5;
227 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
228 assert(std::abs((var - x_var) / x_var) < 0.01);
229 assert(std::abs(skew - x_skew) < 0.02);
230 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
231 }
232 {
233 typedef std::uniform_real_distribution<> D;
234 typedef std::ranlux48_base G;
235 G g;
236 D d;
237 const int N = 100000;
238 std::vector<D::result_type> u;
239 for (int i = 0; i < N; ++i)
240 {
241 D::result_type v = d(g);
242 assert(d.a() <= v && v < d.b());
243 u.push_back(v);
244 }
245 D::result_type mean = std::accumulate(u.begin(), u.end(),
246 D::result_type(0)) / u.size();
247 D::result_type var = 0;
248 D::result_type skew = 0;
249 D::result_type kurtosis = 0;
250 for (int i = 0; i < u.size(); ++i)
251 {
252 D::result_type d = (u[i] - mean);
253 D::result_type d2 = sqr(d);
254 var += d2;
255 skew += d * d2;
256 kurtosis += d2 * d2;
257 }
258 var /= u.size();
259 D::result_type dev = std::sqrt(var);
260 skew /= u.size() * dev * var;
261 kurtosis /= u.size() * var * var;
262 kurtosis -= 3;
263 D::result_type x_mean = (d.a() + d.b()) / 2;
264 D::result_type x_var = sqr(d.b() - d.a()) / 12;
265 D::result_type x_skew = 0;
266 D::result_type x_kurtosis = -6./5;
267 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
268 assert(std::abs((var - x_var) / x_var) < 0.01);
269 assert(std::abs(skew - x_skew) < 0.01);
270 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
271 }
272 {
273 typedef std::uniform_real_distribution<> D;
274 typedef std::ranlux24 G;
275 G g;
276 D d;
277 const int N = 100000;
278 std::vector<D::result_type> u;
279 for (int i = 0; i < N; ++i)
280 {
281 D::result_type v = d(g);
282 assert(d.a() <= v && v < d.b());
283 u.push_back(v);
284 }
285 D::result_type mean = std::accumulate(u.begin(), u.end(),
286 D::result_type(0)) / u.size();
287 D::result_type var = 0;
288 D::result_type skew = 0;
289 D::result_type kurtosis = 0;
290 for (int i = 0; i < u.size(); ++i)
291 {
292 D::result_type d = (u[i] - mean);
293 D::result_type d2 = sqr(d);
294 var += d2;
295 skew += d * d2;
296 kurtosis += d2 * d2;
297 }
298 var /= u.size();
299 D::result_type dev = std::sqrt(var);
300 skew /= u.size() * dev * var;
301 kurtosis /= u.size() * var * var;
302 kurtosis -= 3;
303 D::result_type x_mean = (d.a() + d.b()) / 2;
304 D::result_type x_var = sqr(d.b() - d.a()) / 12;
305 D::result_type x_skew = 0;
306 D::result_type x_kurtosis = -6./5;
307 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
308 assert(std::abs((var - x_var) / x_var) < 0.01);
309 assert(std::abs(skew - x_skew) < 0.01);
310 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
311 }
312 {
313 typedef std::uniform_real_distribution<> D;
314 typedef std::ranlux48 G;
315 G g;
316 D d;
317 const int N = 100000;
318 std::vector<D::result_type> u;
319 for (int i = 0; i < N; ++i)
320 {
321 D::result_type v = d(g);
322 assert(d.a() <= v && v < d.b());
323 u.push_back(v);
324 }
325 D::result_type mean = std::accumulate(u.begin(), u.end(),
326 D::result_type(0)) / u.size();
327 D::result_type var = 0;
328 D::result_type skew = 0;
329 D::result_type kurtosis = 0;
330 for (int i = 0; i < u.size(); ++i)
331 {
332 D::result_type d = (u[i] - mean);
333 D::result_type d2 = sqr(d);
334 var += d2;
335 skew += d * d2;
336 kurtosis += d2 * d2;
337 }
338 var /= u.size();
339 D::result_type dev = std::sqrt(var);
340 skew /= u.size() * dev * var;
341 kurtosis /= u.size() * var * var;
342 kurtosis -= 3;
343 D::result_type x_mean = (d.a() + d.b()) / 2;
344 D::result_type x_var = sqr(d.b() - d.a()) / 12;
345 D::result_type x_skew = 0;
346 D::result_type x_kurtosis = -6./5;
347 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
348 assert(std::abs((var - x_var) / x_var) < 0.01);
349 assert(std::abs(skew - x_skew) < 0.01);
350 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
351 }
352 {
353 typedef std::uniform_real_distribution<> D;
354 typedef std::knuth_b G;
355 G g;
356 D d;
357 const int N = 100000;
358 std::vector<D::result_type> u;
359 for (int i = 0; i < N; ++i)
360 {
361 D::result_type v = d(g);
362 assert(d.a() <= v && v < d.b());
363 u.push_back(v);
364 }
365 D::result_type mean = std::accumulate(u.begin(), u.end(),
366 D::result_type(0)) / u.size();
367 D::result_type var = 0;
368 D::result_type skew = 0;
369 D::result_type kurtosis = 0;
370 for (int i = 0; i < u.size(); ++i)
371 {
372 D::result_type d = (u[i] - mean);
373 D::result_type d2 = sqr(d);
374 var += d2;
375 skew += d * d2;
376 kurtosis += d2 * d2;
377 }
378 var /= u.size();
379 D::result_type dev = std::sqrt(var);
380 skew /= u.size() * dev * var;
381 kurtosis /= u.size() * var * var;
382 kurtosis -= 3;
383 D::result_type x_mean = (d.a() + d.b()) / 2;
384 D::result_type x_var = sqr(d.b() - d.a()) / 12;
385 D::result_type x_skew = 0;
386 D::result_type x_kurtosis = -6./5;
387 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
388 assert(std::abs((var - x_var) / x_var) < 0.01);
389 assert(std::abs(skew - x_skew) < 0.01);
390 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
391 }
392 {
393 typedef std::uniform_real_distribution<> D;
394 typedef std::minstd_rand G;
395 G g;
396 D d(-1, 1);
397 const int N = 100000;
398 std::vector<D::result_type> u;
399 for (int i = 0; i < N; ++i)
400 {
401 D::result_type v = d(g);
402 assert(d.a() <= v && v < d.b());
403 u.push_back(v);
404 }
405 D::result_type mean = std::accumulate(u.begin(), u.end(),
406 D::result_type(0)) / u.size();
407 D::result_type var = 0;
408 D::result_type skew = 0;
409 D::result_type kurtosis = 0;
410 for (int i = 0; i < u.size(); ++i)
411 {
412 D::result_type d = (u[i] - mean);
413 D::result_type d2 = sqr(d);
414 var += d2;
415 skew += d * d2;
416 kurtosis += d2 * d2;
417 }
418 var /= u.size();
419 D::result_type dev = std::sqrt(var);
420 skew /= u.size() * dev * var;
421 kurtosis /= u.size() * var * var;
422 kurtosis -= 3;
423 D::result_type x_mean = (d.a() + d.b()) / 2;
424 D::result_type x_var = sqr(d.b() - d.a()) / 12;
425 D::result_type x_skew = 0;
426 D::result_type x_kurtosis = -6./5;
427 assert(std::abs(mean - x_mean) < 0.01);
428 assert(std::abs((var - x_var) / x_var) < 0.01);
429 assert(std::abs(skew - x_skew) < 0.01);
430 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
431 }
432 {
433 typedef std::uniform_real_distribution<> D;
434 typedef std::minstd_rand G;
435 G g;
436 D d(5.5, 25);
437 const int N = 100000;
438 std::vector<D::result_type> u;
439 for (int i = 0; i < N; ++i)
440 {
441 D::result_type v = d(g);
442 assert(d.a() <= v && v < d.b());
443 u.push_back(v);
444 }
445 D::result_type mean = std::accumulate(u.begin(), u.end(),
446 D::result_type(0)) / u.size();
447 D::result_type var = 0;
448 D::result_type skew = 0;
449 D::result_type kurtosis = 0;
450 for (int i = 0; i < u.size(); ++i)
451 {
452 D::result_type d = (u[i] - mean);
453 D::result_type d2 = sqr(d);
454 var += d2;
455 skew += d * d2;
456 kurtosis += d2 * d2;
457 }
458 var /= u.size();
459 D::result_type dev = std::sqrt(var);
460 skew /= u.size() * dev * var;
461 kurtosis /= u.size() * var * var;
462 kurtosis -= 3;
463 D::result_type x_mean = (d.a() + d.b()) / 2;
464 D::result_type x_var = sqr(d.b() - d.a()) / 12;
465 D::result_type x_skew = 0;
466 D::result_type x_kurtosis = -6./5;
467 assert(std::abs((mean - x_mean) / x_mean) < 0.01);
468 assert(std::abs((var - x_var) / x_var) < 0.01);
469 assert(std::abs(skew - x_skew) < 0.01);
470 assert(std::abs((kurtosis - x_kurtosis) / x_kurtosis) < 0.01);
471 }
472 }
473