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 // REQUIRES: long_tests
11
12 // <random>
13
14 // template<class IntType = int>
15 // class discrete_distribution
16
17 // template<class _URNG> result_type operator()(_URNG& g);
18
19 #include <random>
20 #include <vector>
21 #include <cassert>
22
main()23 int main()
24 {
25 {
26 typedef std::discrete_distribution<> D;
27 typedef std::minstd_rand G;
28 G g;
29 D d;
30 const int N = 100;
31 std::vector<D::result_type> u(d.max()+1);
32 for (int i = 0; i < N; ++i)
33 {
34 D::result_type v = d(g);
35 assert(d.min() <= v && v <= d.max());
36 u[v]++;
37 }
38 std::vector<double> prob = d.probabilities();
39 for (int i = 0; i <= d.max(); ++i)
40 assert((double)u[i]/N == prob[i]);
41 }
42 {
43 typedef std::discrete_distribution<> D;
44 typedef std::minstd_rand G;
45 G g;
46 double p0[] = {.3};
47 D d(p0, p0+1);
48 const int N = 100;
49 std::vector<D::result_type> u(d.max()+1);
50 for (int i = 0; i < N; ++i)
51 {
52 D::result_type v = d(g);
53 assert(d.min() <= v && v <= d.max());
54 u[v]++;
55 }
56 std::vector<double> prob = d.probabilities();
57 for (int i = 0; i <= d.max(); ++i)
58 assert((double)u[i]/N == prob[i]);
59 }
60 {
61 typedef std::discrete_distribution<> D;
62 typedef std::minstd_rand G;
63 G g;
64 double p0[] = {.75, .25};
65 D d(p0, p0+2);
66 const int N = 1000000;
67 std::vector<D::result_type> u(d.max()+1);
68 for (int i = 0; i < N; ++i)
69 {
70 D::result_type v = d(g);
71 assert(d.min() <= v && v <= d.max());
72 u[v]++;
73 }
74 std::vector<double> prob = d.probabilities();
75 for (int i = 0; i <= d.max(); ++i)
76 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
77 }
78 {
79 typedef std::discrete_distribution<> D;
80 typedef std::minstd_rand G;
81 G g;
82 double p0[] = {0, 1};
83 D d(p0, p0+2);
84 const int N = 1000000;
85 std::vector<D::result_type> u(d.max()+1);
86 for (int i = 0; i < N; ++i)
87 {
88 D::result_type v = d(g);
89 assert(d.min() <= v && v <= d.max());
90 u[v]++;
91 }
92 std::vector<double> prob = d.probabilities();
93 assert((double)u[0]/N == prob[0]);
94 assert((double)u[1]/N == prob[1]);
95 }
96 {
97 typedef std::discrete_distribution<> D;
98 typedef std::minstd_rand G;
99 G g;
100 double p0[] = {1, 0};
101 D d(p0, p0+2);
102 const int N = 1000000;
103 std::vector<D::result_type> u(d.max()+1);
104 for (int i = 0; i < N; ++i)
105 {
106 D::result_type v = d(g);
107 assert(d.min() <= v && v <= d.max());
108 u[v]++;
109 }
110 std::vector<double> prob = d.probabilities();
111 assert((double)u[0]/N == prob[0]);
112 assert((double)u[1]/N == prob[1]);
113 }
114 {
115 typedef std::discrete_distribution<> D;
116 typedef std::minstd_rand G;
117 G g;
118 double p0[] = {.3, .1, .6};
119 D d(p0, p0+3);
120 const int N = 10000000;
121 std::vector<D::result_type> u(d.max()+1);
122 for (int i = 0; i < N; ++i)
123 {
124 D::result_type v = d(g);
125 assert(d.min() <= v && v <= d.max());
126 u[v]++;
127 }
128 std::vector<double> prob = d.probabilities();
129 for (int i = 0; i <= d.max(); ++i)
130 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
131 }
132 {
133 typedef std::discrete_distribution<> D;
134 typedef std::minstd_rand G;
135 G g;
136 double p0[] = {0, 25, 75};
137 D d(p0, p0+3);
138 const int N = 1000000;
139 std::vector<D::result_type> u(d.max()+1);
140 for (int i = 0; i < N; ++i)
141 {
142 D::result_type v = d(g);
143 assert(d.min() <= v && v <= d.max());
144 u[v]++;
145 }
146 std::vector<double> prob = d.probabilities();
147 for (int i = 0; i <= d.max(); ++i)
148 if (prob[i] != 0)
149 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
150 else
151 assert(u[i] == 0);
152 }
153 {
154 typedef std::discrete_distribution<> D;
155 typedef std::minstd_rand G;
156 G g;
157 double p0[] = {25, 0, 75};
158 D d(p0, p0+3);
159 const int N = 1000000;
160 std::vector<D::result_type> u(d.max()+1);
161 for (int i = 0; i < N; ++i)
162 {
163 D::result_type v = d(g);
164 assert(d.min() <= v && v <= d.max());
165 u[v]++;
166 }
167 std::vector<double> prob = d.probabilities();
168 for (int i = 0; i <= d.max(); ++i)
169 if (prob[i] != 0)
170 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
171 else
172 assert(u[i] == 0);
173 }
174 {
175 typedef std::discrete_distribution<> D;
176 typedef std::minstd_rand G;
177 G g;
178 double p0[] = {25, 75, 0};
179 D d(p0, p0+3);
180 const int N = 1000000;
181 std::vector<D::result_type> u(d.max()+1);
182 for (int i = 0; i < N; ++i)
183 {
184 D::result_type v = d(g);
185 assert(d.min() <= v && v <= d.max());
186 u[v]++;
187 }
188 std::vector<double> prob = d.probabilities();
189 for (int i = 0; i <= d.max(); ++i)
190 if (prob[i] != 0)
191 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
192 else
193 assert(u[i] == 0);
194 }
195 {
196 typedef std::discrete_distribution<> D;
197 typedef std::minstd_rand G;
198 G g;
199 double p0[] = {0, 0, 1};
200 D d(p0, p0+3);
201 const int N = 100;
202 std::vector<D::result_type> u(d.max()+1);
203 for (int i = 0; i < N; ++i)
204 {
205 D::result_type v = d(g);
206 assert(d.min() <= v && v <= d.max());
207 u[v]++;
208 }
209 std::vector<double> prob = d.probabilities();
210 for (int i = 0; i <= d.max(); ++i)
211 if (prob[i] != 0)
212 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
213 else
214 assert(u[i] == 0);
215 }
216 {
217 typedef std::discrete_distribution<> D;
218 typedef std::minstd_rand G;
219 G g;
220 double p0[] = {0, 1, 0};
221 D d(p0, p0+3);
222 const int N = 100;
223 std::vector<D::result_type> u(d.max()+1);
224 for (int i = 0; i < N; ++i)
225 {
226 D::result_type v = d(g);
227 assert(d.min() <= v && v <= d.max());
228 u[v]++;
229 }
230 std::vector<double> prob = d.probabilities();
231 for (int i = 0; i <= d.max(); ++i)
232 if (prob[i] != 0)
233 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
234 else
235 assert(u[i] == 0);
236 }
237 {
238 typedef std::discrete_distribution<> D;
239 typedef std::minstd_rand G;
240 G g;
241 double p0[] = {1, 0, 0};
242 D d(p0, p0+3);
243 const int N = 100;
244 std::vector<D::result_type> u(d.max()+1);
245 for (int i = 0; i < N; ++i)
246 {
247 D::result_type v = d(g);
248 assert(d.min() <= v && v <= d.max());
249 u[v]++;
250 }
251 std::vector<double> prob = d.probabilities();
252 for (int i = 0; i <= d.max(); ++i)
253 if (prob[i] != 0)
254 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
255 else
256 assert(u[i] == 0);
257 }
258 {
259 typedef std::discrete_distribution<> D;
260 typedef std::minstd_rand G;
261 G g;
262 double p0[] = {33, 0, 0, 67};
263 D d(p0, p0+3);
264 const int N = 1000000;
265 std::vector<D::result_type> u(d.max()+1);
266 for (int i = 0; i < N; ++i)
267 {
268 D::result_type v = d(g);
269 assert(d.min() <= v && v <= d.max());
270 u[v]++;
271 }
272 std::vector<double> prob = d.probabilities();
273 for (int i = 0; i <= d.max(); ++i)
274 if (prob[i] != 0)
275 assert(std::abs((double)u[i]/N - prob[i]) / prob[i] < 0.001);
276 else
277 assert(u[i] == 0);
278 }
279 }
280