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