1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.rng.examples.stress;
18
19 import org.apache.commons.rng.UniformRandomProvider;
20 import org.apache.commons.rng.core.source32.IntProvider;
21 import org.apache.commons.rng.core.source32.RandomIntSource;
22 import org.apache.commons.rng.core.source64.RandomLongSource;
23 import org.apache.commons.rng.core.util.NumberFactory;
24 import org.apache.commons.rng.core.source64.LongProvider;
25
26 import java.io.OutputStream;
27 import java.nio.ByteOrder;
28 import java.util.concurrent.ThreadLocalRandom;
29
30
31
32
33 final class RNGUtils {
34
35 private static final String BYTE_REVERSED = "Byte-reversed ";
36
37 private static final String BIT_REVERSED = "Bit-reversed ";
38
39 private static final String HASH_CODE = "HashCode ^ ";
40
41 private static final String TLR_MIXED = "ThreadLocalRandom ^ ";
42
43 private static final String XOR = " ^ ";
44
45 private static final String UNRECOGNISED_NATIVE_TYPE = "Unrecognised native output type: ";
46
47 private static final String NOT_LONG_SOURCE = "Not a 64-bit long generator: ";
48
49
50 private RNGUtils() {}
51
52
53
54
55
56
57
58
59
60
61
62
63 static UniformRandomProvider createReverseBytesProvider(final UniformRandomProvider rng) {
64 if (rng instanceof RandomIntSource) {
65 return new IntProvider() {
66 @Override
67 public int next() {
68 return Integer.reverseBytes(rng.nextInt());
69 }
70
71 @Override
72 public String toString() {
73 return BYTE_REVERSED + rng.toString();
74 }
75 };
76 }
77 if (rng instanceof RandomLongSource) {
78 return new LongProvider() {
79 @Override
80 public long next() {
81 return Long.reverseBytes(rng.nextLong());
82 }
83
84 @Override
85 public String toString() {
86 return BYTE_REVERSED + rng.toString();
87 }
88 };
89 }
90 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng);
91 }
92
93
94
95
96
97
98
99
100
101
102
103
104 static UniformRandomProvider createReverseBitsProvider(final UniformRandomProvider rng) {
105 if (rng instanceof RandomIntSource) {
106 return new IntProvider() {
107 @Override
108 public int next() {
109 return Integer.reverse(rng.nextInt());
110 }
111
112 @Override
113 public String toString() {
114 return BIT_REVERSED + rng.toString();
115 }
116 };
117 }
118 if (rng instanceof RandomLongSource) {
119 return new LongProvider() {
120 @Override
121 public long next() {
122 return Long.reverse(rng.nextLong());
123 }
124
125 @Override
126 public String toString() {
127 return BIT_REVERSED + rng.toString();
128 }
129 };
130 }
131 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng);
132 }
133
134
135
136
137
138
139
140
141
142 static UniformRandomProvider createIntProvider(final UniformRandomProvider rng) {
143 if (!(rng instanceof RandomIntSource)) {
144 return new IntProvider() {
145 @Override
146 public int next() {
147 return rng.nextInt();
148 }
149
150 @Override
151 public String toString() {
152 return "Int bits " + rng.toString();
153 }
154 };
155 }
156 return rng;
157 }
158
159
160
161
162
163
164
165
166
167
168 static UniformRandomProvider createLongUpperBitsIntProvider(final UniformRandomProvider rng) {
169 if (rng instanceof RandomLongSource) {
170 return new IntProvider() {
171 @Override
172 public int next() {
173 return (int) (rng.nextLong() >>> 32);
174 }
175
176 @Override
177 public String toString() {
178 return "Long upper-bits " + rng.toString();
179 }
180 };
181 }
182 throw new ApplicationException(NOT_LONG_SOURCE + rng);
183 }
184
185
186
187
188
189
190
191
192
193
194 static UniformRandomProvider createLongLowerBitsIntProvider(final UniformRandomProvider rng) {
195 if (rng instanceof RandomLongSource) {
196 return new IntProvider() {
197 @Override
198 public int next() {
199 return (int) rng.nextLong();
200 }
201
202 @Override
203 public String toString() {
204 return "Long lower-bits " + rng.toString();
205 }
206 };
207 }
208 throw new ApplicationException(NOT_LONG_SOURCE + rng);
209 }
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229 static UniformRandomProvider createHashCodeProvider(final UniformRandomProvider rng) {
230 if (rng instanceof RandomIntSource) {
231 return new IntProvider() {
232 @Override
233 public int next() {
234 return System.identityHashCode(new Object()) ^ rng.nextInt();
235 }
236
237 @Override
238 public String toString() {
239 return HASH_CODE + rng.toString();
240 }
241 };
242 }
243 if (rng instanceof RandomLongSource) {
244 return new LongProvider() {
245 @Override
246 public long next() {
247 final long mix = NumberFactory.makeLong(System.identityHashCode(new Object()),
248 System.identityHashCode(new Object()));
249 return mix ^ rng.nextLong();
250 }
251
252 @Override
253 public String toString() {
254 return HASH_CODE + rng.toString();
255 }
256 };
257 }
258 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng);
259 }
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276 static UniformRandomProvider createThreadLocalRandomProvider(final UniformRandomProvider rng) {
277 if (rng instanceof RandomIntSource) {
278 return new IntProvider() {
279 @Override
280 public int next() {
281 return ThreadLocalRandom.current().nextInt() ^ rng.nextInt();
282 }
283
284 @Override
285 public String toString() {
286 return TLR_MIXED + rng.toString();
287 }
288 };
289 }
290 if (rng instanceof RandomLongSource) {
291 return new LongProvider() {
292 @Override
293 public long next() {
294 return ThreadLocalRandom.current().nextLong() ^ rng.nextLong();
295 }
296
297 @Override
298 public String toString() {
299 return TLR_MIXED + rng.toString();
300 }
301 };
302 }
303 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng);
304 }
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322 static UniformRandomProvider createXorProvider(final UniformRandomProvider rng1,
323 final UniformRandomProvider rng2) {
324 if (rng1 instanceof RandomIntSource) {
325 return new IntProvider() {
326 @Override
327 public int next() {
328 return rng1.nextInt() ^ rng2.nextInt();
329 }
330
331 @Override
332 public String toString() {
333 return rng1.toString() + XOR + rng2.toString();
334 }
335 };
336 }
337 if (rng1 instanceof RandomLongSource) {
338 return new LongProvider() {
339 @Override
340 public long next() {
341 return rng1.nextLong() ^ rng2.nextLong();
342 }
343
344 @Override
345 public String toString() {
346 return rng1.toString() + XOR + rng2.toString();
347 }
348 };
349 }
350 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng1);
351 }
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380 static RngDataOutput createDataOutput(final UniformRandomProvider rng, boolean raw64,
381 OutputStream out, int byteSize, ByteOrder byteOrder) {
382 if (rng instanceof RandomIntSource) {
383 return RngDataOutput.ofInt(out, byteSize / 4, byteOrder);
384 }
385 if (rng instanceof RandomLongSource) {
386 return raw64 ?
387 RngDataOutput.ofLong(out, byteSize / 8, byteOrder) :
388 RngDataOutput.ofLongAsInt(out, byteSize / 8, byteOrder);
389 }
390 throw new ApplicationException(UNRECOGNISED_NATIVE_TYPE + rng);
391 }
392
393
394
395
396
397
398
399
400
401
402
403
404 static Object parseArgument(String argument) {
405 try {
406
407
408
409
410 return Integer.parseInt(argument);
411 } catch (final NumberFormatException ex) {
412 throw new ApplicationException("Failed to parse RandomSource argument: " + argument, ex);
413 }
414 }
415 }