|
57547
|
1 |
/*
|
|
|
2 |
* Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
|
|
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
4 |
*
|
|
|
5 |
* This code is free software; you can redistribute it and/or modify it
|
|
|
6 |
* under the terms of the GNU General Public License version 2 only, as
|
|
|
7 |
* published by the Free Software Foundation. Oracle designates this
|
|
|
8 |
* particular file as subject to the "Classpath" exception as provided
|
|
|
9 |
* by Oracle in the LICENSE file that accompanied this code.
|
|
|
10 |
*
|
|
|
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that
|
|
|
15 |
* accompanied this code).
|
|
|
16 |
*
|
|
|
17 |
* You should have received a copy of the GNU General Public License version
|
|
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
20 |
*
|
|
|
21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
|
22 |
* or visit www.oracle.com if you need additional information or have any
|
|
|
23 |
* questions.
|
|
|
24 |
*/
|
|
|
25 |
|
|
|
26 |
package java.util.random;
|
|
|
27 |
|
|
|
28 |
import java.math.BigInteger;
|
|
57671
|
29 |
import java.util.Objects;
|
|
57547
|
30 |
import java.util.stream.DoubleStream;
|
|
|
31 |
import java.util.stream.IntStream;
|
|
|
32 |
import java.util.stream.LongStream;
|
|
|
33 |
import java.util.stream.Stream;
|
|
|
34 |
|
|
|
35 |
/**
|
|
|
36 |
* The {@link RandomGenerator} interface is designed to provide a common protocol for objects
|
|
|
37 |
* that generate random or (more typically) pseudorandom sequences of numbers (or Boolean values).
|
|
|
38 |
* Such a sequence may be obtained by either repeatedly invoking a method that returns a single
|
|
|
39 |
* (pseudo)randomly chosen value, or by invoking a method that returns a stream of (pseudo)randomly
|
|
|
40 |
* chosen values.
|
|
|
41 |
* <p>
|
|
|
42 |
* Ideally, given an implicitly or explicitly specified range of values, each value would be chosen
|
|
|
43 |
* independently and uniformly from that range. In practice, one may have to settle for some
|
|
|
44 |
* approximation to independence and uniformity.
|
|
|
45 |
* <p>
|
|
|
46 |
* In the case of {@code int}, {@code long}, and {@link Boolean} values, if there is no explicit
|
|
|
47 |
* specification of range, then the range includes all possible values of the type. In the case of
|
|
|
48 |
* {@code float} and {@code double} values, a value is always chosen from the set of
|
|
|
49 |
* 2<sup><i>w</i></sup> values between 0.0 (inclusive) and 1.0 (exclusive), where <i>w</i> is 23 for
|
|
|
50 |
* {@code float} values and 52 for {@code double} values, such that adjacent values differ by
|
|
|
51 |
* 2<sup>−<i>w</i></sup>; if an explicit range is specified, then the chosen number is
|
|
|
52 |
* computationally scaled and translated so as to appear to have been chosen from that range.
|
|
|
53 |
* <p>
|
|
|
54 |
* Each method that returns a stream produces a stream of values each of which is chosen in the same
|
|
|
55 |
* manner as for a method that returns a single (pseudo)randomly chosen value. For example, if
|
|
|
56 |
* {@code r} implements {@link RandomGenerator}, then the method call {@code r.ints(100)}
|
|
|
57 |
* returns a stream of 100 {@code int} values. These are not necessarily the exact same values that
|
|
|
58 |
* would have been returned if instead {@code r.nextInt()} had been called 100 times; all that is
|
|
|
59 |
* guaranteed is that each value in the stream is chosen in a similar (pseudo)random manner from the
|
|
|
60 |
* same range.
|
|
|
61 |
* <p>
|
|
|
62 |
* Every object that implements the {@link RandomGenerator} interface is assumed to contain a
|
|
|
63 |
* finite amount of state. Using such an object to generate a pseudorandomly chosen value alters
|
|
|
64 |
* its state. The number of distinct possible states of such an object is called its
|
|
|
65 |
* <i>period</i>. (Some implementations of the {@link RandomGenerator} interface
|
|
|
66 |
* may be truly random rather than pseudorandom, for example relying on the statistical behavior of
|
|
|
67 |
* a physical object to derive chosen values. Such implementations do not have a fixed period.)
|
|
|
68 |
* <p>
|
|
|
69 |
* As a rule, objects that implement the {@link RandomGenerator} interface need not be
|
|
|
70 |
* thread-safe. It is recommended that multithreaded applications use either {@link
|
|
|
71 |
* ThreadLocalRandom} or (preferably) pseudorandom number generators that implement the {@link
|
|
|
72 |
* SplittableGenerator} or {@link JumpableGenerator} interface.
|
|
|
73 |
* <p>
|
|
|
74 |
* To implement this interface, a class only needs to provide concrete definitions for the methods
|
|
|
75 |
* {@code nextLong()} and {@code period()}. Default implementations are provided for all other
|
|
|
76 |
* methods (but it may be desirable to override some of them, especially {@code nextInt()} if the
|
|
|
77 |
* underlying algorithm is {@code int}-based). Moerover, it may be preferable instead to implement
|
|
|
78 |
* another interface such as {@link JumpableGenerator} or {@link LeapableGenerator}, or to extend an abstract
|
|
|
79 |
* class such as {@link AbstractSplittableGenerator} or {@link AbstractArbitrarilyJumpableGenerator}.
|
|
|
80 |
* <p>
|
|
|
81 |
* Objects that implement {@link RandomGenerator} are typically not cryptographically secure.
|
|
|
82 |
* Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
|
|
|
83 |
* pseudorandom number generator for use by security-sensitive applications. Note, however, that
|
|
|
84 |
* {@code java.security.SecureRandom} does implement the {@link RandomGenerator} interface, so
|
|
|
85 |
* that instances of {@code java.security.SecureRandom} may be used interchangeably with other types
|
|
|
86 |
* of pseudorandom generators in applications that do not require a secure generator.
|
|
|
87 |
*
|
|
|
88 |
* @since 14
|
|
|
89 |
*/
|
|
|
90 |
public interface RandomGenerator {
|
|
|
91 |
|
|
|
92 |
/**
|
|
57671
|
93 |
* Supported randpm number Algorithms.
|
|
|
94 |
*/
|
|
|
95 |
public enum Algorithm {
|
|
|
96 |
/**
|
|
|
97 |
* L32X64MixRandom algorithm
|
|
|
98 |
*/
|
|
|
99 |
L32X64MixRandom("L32X64MixRandom"),
|
|
|
100 |
/**
|
|
|
101 |
* L64X1024MixRandom algorithm
|
|
|
102 |
*/
|
|
|
103 |
L64X1024MixRandom("L64X1024MixRandom"),
|
|
|
104 |
/**
|
|
|
105 |
* L64X1024Random algorithm
|
|
|
106 |
*/
|
|
|
107 |
L64X1024Random("L64X1024Random"),
|
|
|
108 |
/**
|
|
|
109 |
* L64X128MixRandom algorithm
|
|
|
110 |
*/
|
|
|
111 |
L64X128MixRandom("L64X128MixRandom"),
|
|
|
112 |
/**
|
|
|
113 |
* L64X128Random algorithm
|
|
|
114 |
*/
|
|
|
115 |
L64X128Random("L64X128Random"),
|
|
|
116 |
/**
|
|
|
117 |
* L64X256MixRandom algorithm
|
|
|
118 |
*/
|
|
|
119 |
L64X256MixRandom("L64X256MixRandom"),
|
|
|
120 |
/**
|
|
|
121 |
* L64X256Random algorithm
|
|
|
122 |
*/
|
|
|
123 |
L64X256Random("L64X256Random"),
|
|
|
124 |
/**
|
|
|
125 |
* L128X256MixRandom algorithm
|
|
|
126 |
*/
|
|
|
127 |
L128X256MixRandom("L128X256MixRandom"),
|
|
|
128 |
/**
|
|
|
129 |
* MRG32k3a algorithm
|
|
|
130 |
*/
|
|
|
131 |
MRG32k3a("MRG32k3a"),
|
|
|
132 |
/**
|
|
|
133 |
* Xoroshiro128Plus algorithm
|
|
|
134 |
*/
|
|
|
135 |
Xoroshiro128Plus("Xoroshiro128Plus"),
|
|
|
136 |
/**
|
|
|
137 |
* Xoroshiro128StarStar algorithm
|
|
|
138 |
*/
|
|
|
139 |
Xoroshiro128StarStar("Xoroshiro128StarStar"),
|
|
|
140 |
/**
|
|
|
141 |
* Xoshiro256StarStar algorithm
|
|
|
142 |
*/
|
|
|
143 |
Xoshiro256StarStar("Xoshiro256StarStar");
|
|
|
144 |
|
|
|
145 |
private String name;
|
|
|
146 |
|
|
|
147 |
Algorithm(String name) {
|
|
|
148 |
this.name = name;
|
|
|
149 |
}
|
|
|
150 |
|
|
|
151 |
public String toString() {
|
|
|
152 |
return name;
|
|
|
153 |
}
|
|
|
154 |
}
|
|
|
155 |
|
|
|
156 |
/**
|
|
|
157 |
* Returns an instance of {@link RandomGenerator} that utilizes the
|
|
|
158 |
* {@code name} algorithm.
|
|
|
159 |
*
|
|
|
160 |
* @param name Name of random number generator algorithm
|
|
|
161 |
*
|
|
|
162 |
* @return An instance of {@link RandomGenerator}
|
|
|
163 |
*/
|
|
|
164 |
public static RandomGenerator of(String name) {
|
|
|
165 |
Objects.requireNonNull(name);
|
|
|
166 |
return RandomGeneratorFactory.of(name, RandomGenerator.class);
|
|
|
167 |
}
|
|
|
168 |
|
|
|
169 |
/**
|
|
|
170 |
* Returns an instance of {@link RandomGenerator} that utilizes the
|
|
|
171 |
* specified {@code algorithm}.
|
|
|
172 |
*
|
|
|
173 |
* @param algorithm Random number generator algorithm
|
|
|
174 |
*
|
|
|
175 |
* @return An instance of {@link RandomGenerator}
|
|
|
176 |
*/
|
|
|
177 |
public static RandomGenerator of(Algorithm algorithm) {
|
|
|
178 |
Objects.requireNonNull(algorithm);
|
|
|
179 |
return RandomGeneratorFactory.of(algorithm.toString(), RandomGenerator.class);
|
|
|
180 |
}
|
|
|
181 |
|
|
|
182 |
/**
|
|
|
183 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
184 |
* of {@link RandomGenerator} that utilizes the {@code name} algorithm.
|
|
|
185 |
*
|
|
|
186 |
* @param name Name of random number generator algorithm
|
|
|
187 |
*
|
|
|
188 |
* @return Factory of {@link RandomGenerator}
|
|
|
189 |
*/
|
|
|
190 |
public static RandomGeneratorFactory<RandomGenerator> factoryOf(String name) {
|
|
|
191 |
Objects.requireNonNull(name);
|
|
|
192 |
return RandomGeneratorFactory.factoryOf(name, RandomGenerator.class);
|
|
|
193 |
}
|
|
|
194 |
|
|
|
195 |
/**
|
|
|
196 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
197 |
* of {@link RandomGenerator} that utilizes the specified {@code algorithm}.
|
|
|
198 |
*
|
|
|
199 |
* @param algorithm Random number generator algorithm
|
|
|
200 |
*
|
|
|
201 |
* @return Factory of {@link RandomGenerator}
|
|
|
202 |
*/
|
|
|
203 |
public static RandomGeneratorFactory<RandomGenerator> factoryOf(Algorithm algorithm) {
|
|
|
204 |
Objects.requireNonNull(algorithm);
|
|
|
205 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), RandomGenerator.class);
|
|
|
206 |
}
|
|
|
207 |
|
|
|
208 |
/**
|
|
57547
|
209 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
210 |
* {@code double} values.
|
|
|
211 |
*
|
|
|
212 |
* @return a stream of pseudorandomly chosen {@code double} values
|
|
|
213 |
*
|
|
|
214 |
* @implNote It is permitted to implement this method in a manner
|
|
|
215 |
* equivalent to {@code doubles(Long.MAX_VALUE)}.
|
|
|
216 |
*
|
|
|
217 |
* @implNote The default implementation produces a sequential stream
|
|
|
218 |
* that repeatedly calls {@code nextDouble()}.
|
|
|
219 |
*/
|
|
|
220 |
default DoubleStream doubles() {
|
|
|
221 |
return DoubleStream.generate(this::nextDouble).sequential();
|
|
|
222 |
}
|
|
|
223 |
|
|
|
224 |
/**
|
|
|
225 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
226 |
* {@code double} values, where each value is between the specified
|
|
|
227 |
* origin (inclusive) and the specified bound (exclusive).
|
|
|
228 |
*
|
|
|
229 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
230 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
231 |
*
|
|
|
232 |
* @return a stream of pseudorandomly chosen {@code double} values, each between
|
|
|
233 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
234 |
*
|
|
|
235 |
* @throws IllegalArgumentException if {@code randomNumberOrigin}
|
|
|
236 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
237 |
*
|
|
|
238 |
* @implNote It is permitted to implement this method in a manner
|
|
|
239 |
* equivalent to
|
|
|
240 |
* {@code doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
|
|
|
241 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
242 |
* calls {@code nextDouble(randomNumberOrigin, randomNumberBound)}.
|
|
|
243 |
*/
|
|
|
244 |
default DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
|
|
|
245 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
246 |
return DoubleStream.generate(() -> nextDouble(randomNumberOrigin, randomNumberBound)).sequential();
|
|
|
247 |
}
|
|
|
248 |
|
|
|
249 |
/**
|
|
|
250 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
251 |
* pseudorandomly chosen {@code double} values.
|
|
|
252 |
*
|
|
|
253 |
* @param streamSize the number of values to generate
|
|
|
254 |
*
|
|
|
255 |
* @return a stream of pseudorandomly chosen {@code double} values
|
|
|
256 |
*
|
|
|
257 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
258 |
* less than zero
|
|
|
259 |
*
|
|
|
260 |
* @implNote The default implementation produces a sequential stream
|
|
|
261 |
* that repeatedly calls {@code nextDouble()}.
|
|
|
262 |
*/
|
|
|
263 |
default DoubleStream doubles(long streamSize) {
|
|
|
264 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
265 |
return doubles().limit(streamSize);
|
|
|
266 |
}
|
|
|
267 |
|
|
|
268 |
/**
|
|
|
269 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
270 |
* pseudorandomly chosen {@code double} values, where each value is between
|
|
|
271 |
* the specified origin (inclusive) and the specified bound (exclusive).
|
|
|
272 |
*
|
|
|
273 |
* @param streamSize the number of values to generate
|
|
|
274 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
275 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
276 |
*
|
|
|
277 |
* @return a stream of pseudorandomly chosen {@code double} values, each between
|
|
|
278 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
279 |
*
|
|
|
280 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
281 |
* less than zero, or {@code randomNumberOrigin}
|
|
|
282 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
283 |
*
|
|
|
284 |
* @implNote The default implementation produces a sequential stream
|
|
|
285 |
* that repeatedly calls {@code nextDouble(randomNumberOrigin, randomNumberBound)}.
|
|
|
286 |
*/
|
|
|
287 |
default DoubleStream doubles(long streamSize, double randomNumberOrigin,
|
|
|
288 |
double randomNumberBound) {
|
|
|
289 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
290 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
291 |
return doubles(randomNumberOrigin, randomNumberBound).limit(streamSize);
|
|
|
292 |
}
|
|
|
293 |
|
|
|
294 |
/**
|
|
|
295 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
296 |
* {@code int} values.
|
|
|
297 |
*
|
|
|
298 |
* @return a stream of pseudorandomly chosen {@code int} values
|
|
|
299 |
*
|
|
|
300 |
* @implNote It is permitted to implement this method in a manner
|
|
|
301 |
* equivalent to {@code ints(Long.MAX_VALUE)}.
|
|
|
302 |
* @implNote The default implementation produces a sequential stream
|
|
|
303 |
* that repeatedly calls {@code nextInt()}.
|
|
|
304 |
*/
|
|
|
305 |
default IntStream ints() {
|
|
|
306 |
return IntStream.generate(this::nextInt).sequential();
|
|
|
307 |
}
|
|
|
308 |
|
|
|
309 |
/**
|
|
|
310 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
311 |
* {@code int} values, where each value is between the specified
|
|
|
312 |
* origin (inclusive) and the specified bound (exclusive).
|
|
|
313 |
*
|
|
|
314 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
315 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
316 |
*
|
|
|
317 |
* @return a stream of pseudorandomly chosen {@code int} values, each between
|
|
|
318 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
319 |
*
|
|
|
320 |
* @throws IllegalArgumentException if {@code randomNumberOrigin}
|
|
|
321 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
322 |
*
|
|
|
323 |
* @implNote It is permitted to implement this method in a manner equivalent to
|
|
|
324 |
* {@code ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
|
|
|
325 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
326 |
* calls {@code nextInt(randomNumberOrigin, randomNumberBound)}.
|
|
|
327 |
*/
|
|
|
328 |
default IntStream ints(int randomNumberOrigin, int randomNumberBound) {
|
|
|
329 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
330 |
return IntStream.generate(() -> nextInt(randomNumberOrigin, randomNumberBound)).sequential();
|
|
|
331 |
}
|
|
|
332 |
|
|
|
333 |
/**
|
|
|
334 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
335 |
* pseudorandomly chosen {@code int} values.
|
|
|
336 |
*
|
|
|
337 |
* @param streamSize the number of values to generate
|
|
|
338 |
*
|
|
|
339 |
* @return a stream of pseudorandomly chosen {@code int} values
|
|
|
340 |
*
|
|
|
341 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
342 |
* less than zero
|
|
|
343 |
*
|
|
|
344 |
* @implNote The default implementation produces a sequential stream
|
|
|
345 |
* that repeatedly calls {@code nextInt()}.
|
|
|
346 |
*/
|
|
|
347 |
default IntStream ints(long streamSize) {
|
|
|
348 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
349 |
return ints().limit(streamSize);
|
|
|
350 |
}
|
|
|
351 |
|
|
|
352 |
/**
|
|
|
353 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
354 |
* pseudorandomly chosen {@code int} values, where each value is between
|
|
|
355 |
* the specified origin (inclusive) and the specified bound (exclusive).
|
|
|
356 |
*
|
|
|
357 |
* @param streamSize the number of values to generate
|
|
|
358 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
359 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
360 |
*
|
|
|
361 |
* @return a stream of pseudorandomly chosen {@code int} values, each between
|
|
|
362 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
363 |
*
|
|
|
364 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
365 |
* less than zero, or {@code randomNumberOrigin}
|
|
|
366 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
367 |
*
|
|
|
368 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
369 |
* calls {@code nextInt(randomNumberOrigin, randomNumberBound)}.
|
|
|
370 |
*/
|
|
|
371 |
default IntStream ints(long streamSize, int randomNumberOrigin,
|
|
|
372 |
int randomNumberBound) {
|
|
|
373 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
374 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
375 |
return ints(randomNumberOrigin, randomNumberBound).limit(streamSize);
|
|
|
376 |
}
|
|
|
377 |
|
|
|
378 |
/**
|
|
|
379 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
380 |
* {@code long} values.
|
|
|
381 |
*
|
|
|
382 |
* @return a stream of pseudorandomly chosen {@code long} values
|
|
|
383 |
*
|
|
|
384 |
* @implNote It is permitted to implement this method in a manner
|
|
|
385 |
* equivalent to {@code longs(Long.MAX_VALUE)}.
|
|
|
386 |
* @implNote The default implementation produces a sequential stream
|
|
|
387 |
* that repeatedly calls {@code nextLong()}.
|
|
|
388 |
*/
|
|
|
389 |
default LongStream longs() {
|
|
|
390 |
return LongStream.generate(this::nextLong).sequential();
|
|
|
391 |
}
|
|
|
392 |
|
|
|
393 |
/**
|
|
|
394 |
* Returns an effectively unlimited stream of pseudorandomly chosen
|
|
|
395 |
* {@code long} values, where each value is between the specified
|
|
|
396 |
* origin (inclusive) and the specified bound (exclusive).
|
|
|
397 |
*
|
|
|
398 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
399 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
400 |
*
|
|
|
401 |
* @return a stream of pseudorandomly chosen {@code long} values, each between
|
|
|
402 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
403 |
*
|
|
|
404 |
* @throws IllegalArgumentException if {@code randomNumberOrigin}
|
|
|
405 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
406 |
*
|
|
|
407 |
* @implNote It is permitted to implement this method in a manner
|
|
|
408 |
* equivalent to {@code longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}.
|
|
|
409 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
410 |
* calls {@code nextLong(randomNumberOrigin, randomNumberBound)}.
|
|
|
411 |
*/
|
|
|
412 |
default LongStream longs(long randomNumberOrigin, long randomNumberBound) {
|
|
|
413 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
414 |
return LongStream.generate(() -> nextLong(randomNumberOrigin, randomNumberBound)).sequential();
|
|
|
415 |
}
|
|
|
416 |
|
|
|
417 |
/**
|
|
|
418 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
419 |
* pseudorandomly chosen {@code long} values.
|
|
|
420 |
*
|
|
|
421 |
* @param streamSize the number of values to generate
|
|
|
422 |
*
|
|
|
423 |
* @return a stream of pseudorandomly chosen {@code long} values
|
|
|
424 |
*
|
|
|
425 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
426 |
* less than zero
|
|
|
427 |
*
|
|
|
428 |
* @implNote The default implementation produces a sequential stream
|
|
|
429 |
* that repeatedly calls {@code nextLong()}.
|
|
|
430 |
*/
|
|
|
431 |
default LongStream longs(long streamSize) {
|
|
|
432 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
433 |
return longs().limit(streamSize);
|
|
|
434 |
}
|
|
|
435 |
|
|
|
436 |
/**
|
|
|
437 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
438 |
* pseudorandomly chosen {@code long} values, where each value is between
|
|
|
439 |
* the specified origin (inclusive) and the specified bound (exclusive).
|
|
|
440 |
*
|
|
|
441 |
* @param streamSize the number of values to generate
|
|
|
442 |
* @param randomNumberOrigin the least value that can be produced
|
|
|
443 |
* @param randomNumberBound the upper bound (exclusive) for each value produced
|
|
|
444 |
*
|
|
|
445 |
* @return a stream of pseudorandomly chosen {@code long} values, each between
|
|
|
446 |
* the specified origin (inclusive) and the specified bound (exclusive)
|
|
|
447 |
*
|
|
|
448 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
449 |
* less than zero, or {@code randomNumberOrigin}
|
|
|
450 |
* is greater than or equal to {@code randomNumberBound}
|
|
|
451 |
*
|
|
|
452 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
453 |
* calls {@code nextLong(randomNumberOrigin, randomNumberBound)}.
|
|
|
454 |
*/
|
|
|
455 |
default LongStream longs(long streamSize, long randomNumberOrigin,
|
|
|
456 |
long randomNumberBound) {
|
|
|
457 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
458 |
RandomSupport.checkRange(randomNumberOrigin, randomNumberBound);
|
|
|
459 |
return longs(randomNumberOrigin, randomNumberBound).limit(streamSize);
|
|
|
460 |
}
|
|
|
461 |
|
|
|
462 |
/**
|
|
|
463 |
* Returns a pseudorandomly chosen {@code boolean} value.
|
|
|
464 |
* <p>
|
|
|
465 |
* The default implementation tests the high-order bit (sign bit) of a value produced by {@code
|
|
|
466 |
* nextInt()}, on the grounds that some algorithms for pseudorandom number generation produce
|
|
|
467 |
* values whose high-order bits have better statistical quality than the low-order bits.
|
|
|
468 |
*
|
|
|
469 |
* @return a pseudorandomly chosen {@code boolean} value
|
|
|
470 |
*/
|
|
|
471 |
default boolean nextBoolean() {
|
|
|
472 |
return nextInt() < 0;
|
|
|
473 |
}
|
|
|
474 |
|
|
|
475 |
/**
|
|
|
476 |
* Returns a pseudorandom {@code float} value between zero (inclusive) and one (exclusive).
|
|
|
477 |
* <p>
|
|
|
478 |
* The default implementation uses the 24 high-order bits from a call to {@code nextInt()}.
|
|
|
479 |
*
|
|
|
480 |
* @return a pseudorandom {@code float} value between zero (inclusive) and one (exclusive)
|
|
|
481 |
*/
|
|
|
482 |
default float nextFloat() {
|
|
|
483 |
return (nextInt() >>> 8) * 0x1.0p-24f;
|
|
|
484 |
}
|
|
|
485 |
|
|
|
486 |
/**
|
|
|
487 |
* Returns a pseudorandomly chosen {@code float} value between zero
|
|
|
488 |
* (inclusive) and the specified bound (exclusive).
|
|
|
489 |
*
|
|
|
490 |
* @param bound the upper bound (exclusive) for the returned value.
|
|
|
491 |
* Must be positive and finite
|
|
|
492 |
*
|
|
|
493 |
* @return a pseudorandomly chosen {@code float} value between
|
|
|
494 |
* zero (inclusive) and the bound (exclusive)
|
|
|
495 |
*
|
|
|
496 |
* @throws IllegalArgumentException if {@code bound} is not
|
|
|
497 |
* positive and finite
|
|
|
498 |
*
|
|
|
499 |
* @implNote The default implementation simply calls
|
|
|
500 |
* {@code RandomSupport.checkBound(bound)} and then
|
|
|
501 |
* {@code RandomSupport.boundedNextFloat(this, bound)}.
|
|
|
502 |
*/
|
|
|
503 |
default float nextFloat(float bound) {
|
|
|
504 |
RandomSupport.checkBound(bound);
|
|
|
505 |
return RandomSupport.boundedNextFloat(this, bound);
|
|
|
506 |
}
|
|
|
507 |
|
|
|
508 |
/**
|
|
|
509 |
* Returns a pseudorandomly chosen {@code float} value between the
|
|
|
510 |
* specified origin (inclusive) and the specified bound (exclusive).
|
|
|
511 |
*
|
|
|
512 |
* @param origin the least value that can be returned
|
|
|
513 |
* @param bound the upper bound (exclusive)
|
|
|
514 |
*
|
|
|
515 |
* @return a pseudorandomly chosen {@code float} value between the
|
|
|
516 |
* origin (inclusive) and the bound (exclusive)
|
|
|
517 |
*
|
|
|
518 |
* @throws IllegalArgumentException unless {@code origin} is finite,
|
|
|
519 |
* {@code bound} is finite, and {@code origin} is less than
|
|
|
520 |
* {@code bound}
|
|
|
521 |
*
|
|
|
522 |
* @implNote The default implementation simply calls
|
|
|
523 |
* {@code RandomSupport.checkRange(origin, bound)} and then
|
|
|
524 |
* {@code RandomSupport.boundedNextFloat(this, origin, bound)}.
|
|
|
525 |
*/
|
|
|
526 |
default float nextFloat(float origin, float bound) {
|
|
|
527 |
RandomSupport.checkRange(origin, bound);
|
|
|
528 |
return RandomSupport.boundedNextFloat(this, origin, bound);
|
|
|
529 |
}
|
|
|
530 |
|
|
|
531 |
/**
|
|
|
532 |
* Returns a pseudorandom {@code double} value between zero (inclusive) and one (exclusive).
|
|
|
533 |
* <p>
|
|
|
534 |
* The default implementation uses the 53 high-order bits from a call to {@code nextLong()}.
|
|
|
535 |
*
|
|
|
536 |
* @return a pseudorandom {@code double} value between zero (inclusive) and one (exclusive)
|
|
|
537 |
*/
|
|
|
538 |
default double nextDouble() {
|
|
|
539 |
return (nextLong() >>> 11) * 0x1.0p-53;
|
|
|
540 |
}
|
|
|
541 |
|
|
|
542 |
/**
|
|
|
543 |
* Returns a pseudorandomly chosen {@code double} value between zero
|
|
|
544 |
* (inclusive) and the specified bound (exclusive).
|
|
|
545 |
*
|
|
|
546 |
* @param bound the upper bound (exclusive) for the returned value.
|
|
|
547 |
* Must be positive and finite
|
|
|
548 |
*
|
|
|
549 |
* @return a pseudorandomly chosen {@code double} value between
|
|
|
550 |
* zero (inclusive) and the bound (exclusive)
|
|
|
551 |
*
|
|
|
552 |
* @throws IllegalArgumentException if {@code bound} is not
|
|
|
553 |
* positive and finite
|
|
|
554 |
*
|
|
|
555 |
* @implNote The default implementation simply calls
|
|
|
556 |
* {@code RandomSupport.checkBound(bound)} and then
|
|
|
557 |
* {@code RandomSupport.boundedNextDouble(this, bound)}.
|
|
|
558 |
*/
|
|
|
559 |
default double nextDouble(double bound) {
|
|
|
560 |
RandomSupport.checkBound(bound);
|
|
|
561 |
return RandomSupport.boundedNextDouble(this, bound);
|
|
|
562 |
}
|
|
|
563 |
|
|
|
564 |
/**
|
|
|
565 |
* Returns a pseudorandomly chosen {@code double} value between the
|
|
|
566 |
* specified origin (inclusive) and the specified bound (exclusive).
|
|
|
567 |
*
|
|
|
568 |
* @param origin the least value that can be returned
|
|
|
569 |
* @param bound the upper bound (exclusive) for the returned value
|
|
|
570 |
*
|
|
|
571 |
* @return a pseudorandomly chosen {@code double} value between the
|
|
|
572 |
* origin (inclusive) and the bound (exclusive)
|
|
|
573 |
*
|
|
|
574 |
* @throws IllegalArgumentException unless {@code origin} is finite,
|
|
|
575 |
* {@code bound} is finite, and {@code origin} is less than
|
|
|
576 |
* {@code bound}
|
|
|
577 |
*
|
|
|
578 |
* @implNote The default implementation simply calls
|
|
|
579 |
* {@code RandomSupport.checkRange(origin, bound)} and then
|
|
|
580 |
* {@code RandomSupport.boundedNextDouble(this, origin, bound)}.
|
|
|
581 |
*/
|
|
|
582 |
default double nextDouble(double origin, double bound) {
|
|
|
583 |
RandomSupport.checkRange(origin, bound);
|
|
|
584 |
return RandomSupport.boundedNextDouble(this, origin, bound);
|
|
|
585 |
}
|
|
|
586 |
|
|
|
587 |
/**
|
|
|
588 |
* Returns a pseudorandomly chosen {@code int} value.
|
|
|
589 |
* <p>
|
|
|
590 |
* The default implementation uses the 32 high-order bits from a call to {@code nextLong()}.
|
|
|
591 |
*
|
|
|
592 |
* @return a pseudorandomly chosen {@code int} value
|
|
|
593 |
*/
|
|
|
594 |
default public int nextInt() {
|
|
|
595 |
return (int)(nextLong() >>> 32);
|
|
|
596 |
}
|
|
|
597 |
|
|
|
598 |
/**
|
|
|
599 |
* Returns a pseudorandomly chosen {@code int} value between
|
|
|
600 |
* zero (inclusive) and the specified bound (exclusive).
|
|
|
601 |
*
|
|
|
602 |
* @param bound the upper bound (exclusive) for the returned value. Must be positive.
|
|
|
603 |
*
|
|
|
604 |
* @return a pseudorandomly chosen {@code int} value between
|
|
|
605 |
* zero (inclusive) and the bound (exclusive)
|
|
|
606 |
*
|
|
|
607 |
* @throws IllegalArgumentException if {@code bound} is not positive
|
|
|
608 |
*
|
|
|
609 |
* @implNote The default implementation simply calls
|
|
|
610 |
* {@code RandomSupport.checkBound(bound)} and then
|
|
|
611 |
* {@code RandomSupport.boundedNextInt(this, bound)}.
|
|
|
612 |
*/
|
|
|
613 |
default int nextInt(int bound) {
|
|
|
614 |
RandomSupport.checkBound(bound);
|
|
|
615 |
return RandomSupport.boundedNextInt(this, bound);
|
|
|
616 |
}
|
|
|
617 |
|
|
|
618 |
/**
|
|
|
619 |
* Returns a pseudorandomly chosen {@code int} value between the
|
|
|
620 |
* specified origin (inclusive) and the specified bound (exclusive).
|
|
|
621 |
*
|
|
|
622 |
* @param origin the least value that can be returned
|
|
|
623 |
* @param bound the upper bound (exclusive) for the returned value
|
|
|
624 |
*
|
|
|
625 |
* @return a pseudorandomly chosen {@code int} value between the
|
|
|
626 |
* origin (inclusive) and the bound (exclusive)
|
|
|
627 |
*
|
|
|
628 |
* @throws IllegalArgumentException if {@code origin} is greater than
|
|
|
629 |
* or equal to {@code bound}
|
|
|
630 |
*
|
|
|
631 |
* @implNote The default implementation simply calls
|
|
|
632 |
* {@code RandomSupport.checkRange(origin, bound)} and then
|
|
|
633 |
* {@code RandomSupport.boundedNextInt(this, origin, bound)}.
|
|
|
634 |
*/
|
|
|
635 |
default int nextInt(int origin, int bound) {
|
|
|
636 |
RandomSupport.checkRange(origin, bound);
|
|
|
637 |
return RandomSupport.boundedNextInt(this, origin, bound);
|
|
|
638 |
}
|
|
|
639 |
|
|
|
640 |
/**
|
|
|
641 |
* Returns a pseudorandomly chosen {@code long} value.
|
|
|
642 |
*
|
|
|
643 |
* @return a pseudorandomly chosen {@code long} value
|
|
|
644 |
*/
|
|
|
645 |
long nextLong();
|
|
|
646 |
|
|
|
647 |
/**
|
|
|
648 |
* Returns a pseudorandomly chosen {@code long} value between
|
|
|
649 |
* zero (inclusive) and the specified bound (exclusive).
|
|
|
650 |
*
|
|
|
651 |
* @param bound the upper bound (exclusive) for the returned value. Must be positive.
|
|
|
652 |
*
|
|
|
653 |
* @return a pseudorandomly chosen {@code long} value between
|
|
|
654 |
* zero (inclusive) and the bound (exclusive)
|
|
|
655 |
*
|
|
|
656 |
* @throws IllegalArgumentException if {@code bound} is not positive
|
|
|
657 |
*
|
|
|
658 |
* @implNote The default implementation simply calls
|
|
|
659 |
* {@code RandomSupport.checkBound(bound)} and then
|
|
|
660 |
* {@code RandomSupport.boundedNextLong(this, bound)}.
|
|
|
661 |
*/
|
|
|
662 |
default long nextLong(long bound) {
|
|
|
663 |
RandomSupport.checkBound(bound);
|
|
|
664 |
return RandomSupport.boundedNextLong(this, bound);
|
|
|
665 |
}
|
|
|
666 |
|
|
|
667 |
/**
|
|
|
668 |
* Returns a pseudorandomly chosen {@code long} value between the
|
|
|
669 |
* specified origin (inclusive) and the specified bound (exclusive).
|
|
|
670 |
*
|
|
|
671 |
* @param origin the least value that can be returned
|
|
|
672 |
* @param bound the upper bound (exclusive) for the returned value
|
|
|
673 |
*
|
|
|
674 |
* @return a pseudorandomly chosen {@code long} value between the
|
|
|
675 |
* origin (inclusive) and the bound (exclusive)
|
|
|
676 |
*
|
|
|
677 |
* @throws IllegalArgumentException if {@code origin} is greater than
|
|
|
678 |
* or equal to {@code bound}
|
|
|
679 |
*
|
|
|
680 |
* @implNote The default implementation simply calls
|
|
|
681 |
* {@code RandomSupport.checkRange(origin, bound)} and then
|
|
|
682 |
* {@code RandomSupport.boundedNextInt(this, origin, bound)}.
|
|
|
683 |
*
|
|
|
684 |
*/
|
|
|
685 |
default long nextLong(long origin, long bound) {
|
|
|
686 |
RandomSupport.checkRange(origin, bound);
|
|
|
687 |
return RandomSupport.boundedNextLong(this, origin, bound);
|
|
|
688 |
}
|
|
|
689 |
|
|
|
690 |
/**
|
|
|
691 |
* Returns a {@code double} value pseudorandomly chosen from
|
|
|
692 |
* a Gaussian (normal) distribution whose mean is 0 and whose
|
|
|
693 |
* standard deviation is 1.
|
|
|
694 |
*
|
|
|
695 |
* @return a {@code double} value pseudorandomly chosen from a
|
|
|
696 |
* Gaussian distribution
|
|
|
697 |
*/
|
|
|
698 |
default double nextGaussian() {
|
|
|
699 |
return RandomSupport.computeNextGaussian(this);
|
|
|
700 |
}
|
|
|
701 |
|
|
|
702 |
/**
|
|
|
703 |
* Returns a {@code double} value pseudorandomly chosen from
|
|
|
704 |
* a Gaussian (normal) distribution with a mean and
|
|
|
705 |
* standard deviation specified by the arguments.
|
|
|
706 |
*
|
|
|
707 |
* @param mean the mean of the Gaussian distribution to be drawn from
|
|
|
708 |
* @param stddev the standard deviation (square root of the variance)
|
|
|
709 |
* of the Gaussian distribution to be drawn from
|
|
|
710 |
*
|
|
|
711 |
* @return a {@code double} value pseudorandomly chosen from the
|
|
|
712 |
* specified Gaussian distribution
|
|
|
713 |
*
|
|
|
714 |
* @throws IllegalArgumentException if {@code stddev} is negative
|
|
|
715 |
*/
|
|
|
716 |
default double nextGaussian(double mean, double stddev) {
|
|
|
717 |
if (stddev < 0.0) throw new IllegalArgumentException("standard deviation must be non-negative");
|
|
|
718 |
return mean + stddev * RandomSupport.computeNextGaussian(this);
|
|
|
719 |
}
|
|
|
720 |
|
|
|
721 |
/**
|
|
|
722 |
* Returns a nonnegative {@code double} value pseudorandomly chosen
|
|
|
723 |
* from an exponential distribution whose mean is 1.
|
|
|
724 |
*
|
|
|
725 |
* @return a nonnegative {@code double} value pseudorandomly chosen from an
|
|
|
726 |
* exponential distribution
|
|
|
727 |
*/
|
|
|
728 |
default double nextExponential() {
|
|
|
729 |
return RandomSupport.computeNextExponential(this);
|
|
|
730 |
}
|
|
|
731 |
|
|
|
732 |
/**
|
|
|
733 |
* Returns the period of this {@link RandomGenerator} object.
|
|
|
734 |
*
|
|
|
735 |
* @return a {@link BigInteger} whose value is the number of distinct possible states of this
|
|
|
736 |
* {@link RandomGenerator} object, or 0 if unknown, or negative if extremely
|
|
|
737 |
* large.
|
|
|
738 |
*/
|
|
|
739 |
BigInteger period();
|
|
|
740 |
|
|
|
741 |
/**
|
|
|
742 |
* The value (0) returned by the {@code period()} method if the period is unknown.
|
|
|
743 |
*/
|
|
|
744 |
static final BigInteger UNKNOWN_PERIOD = BigInteger.ZERO;
|
|
|
745 |
|
|
|
746 |
/**
|
|
|
747 |
* The (negative) value returned by the {@code period()} method if this generator
|
|
|
748 |
* has no period because it is truly random rather than just pseudorandom.
|
|
|
749 |
*/
|
|
|
750 |
static final BigInteger TRULY_RANDOM = BigInteger.valueOf(-1);
|
|
|
751 |
|
|
|
752 |
/**
|
|
|
753 |
* The (negative) value that may be returned by the {@code period()} method
|
|
|
754 |
* if this generator has a huge period (larger than 2**(2**16)).
|
|
|
755 |
*/
|
|
|
756 |
static final BigInteger HUGE_PERIOD = BigInteger.valueOf(-2);
|
|
|
757 |
|
|
|
758 |
/**
|
|
|
759 |
* The {@link StreamableGenerator} interface augments the {@link RandomGenerator} interface
|
|
|
760 |
* to provide methods that return streams of {@link RandomGenerator} objects.
|
|
|
761 |
* Ideally, such a stream of objects would have the property that the
|
|
|
762 |
* behavior of each object is statistically independent of all the others.
|
|
|
763 |
* In practice, one may have to settle for some approximation to this property.
|
|
|
764 |
*
|
|
|
765 |
* A generator that implements interface {@link SplittableGenerator}
|
|
|
766 |
* may choose to use its {@code splits} method to implement the {@code rngs}
|
|
|
767 |
* method required by this interface.
|
|
|
768 |
*
|
|
|
769 |
* A generator that implements interface {@link JumpableGenerator}
|
|
|
770 |
* may choose to use its {@code jumps} method to implement the {@code rngs}
|
|
|
771 |
* method required by this interface.
|
|
|
772 |
*
|
|
|
773 |
* A generator that implements interface {@link LeapableGenerator}
|
|
|
774 |
* may choose to use its {@code leaps} method to implement the {@code rngs}
|
|
|
775 |
* method required by this interface.
|
|
|
776 |
* <p>
|
|
|
777 |
* An implementation of the {@link StreamableGenerator} interface must provide
|
|
|
778 |
* concrete definitions for the methods {@code nextInt()}, {@code nextLong},
|
|
|
779 |
* {@code period()}, and {@code rngs()}.
|
|
|
780 |
* Default implementations are provided for all other methods.
|
|
|
781 |
* <p>
|
|
|
782 |
* Objects that implement {@link StreamableGenerator} are typically
|
|
|
783 |
* not cryptographically secure. Consider instead using
|
|
|
784 |
* {@link java.security.SecureRandom} to get a cryptographically
|
|
|
785 |
* secure pseudo-random number generator for use by
|
|
|
786 |
* security-sensitive applications.
|
|
|
787 |
*
|
|
|
788 |
* @since 14
|
|
|
789 |
*/
|
|
|
790 |
public interface StreamableGenerator extends RandomGenerator {
|
|
57671
|
791 |
|
|
|
792 |
/**
|
|
|
793 |
* Returns an instance of {@link StreamableGenerator} that utilizes the
|
|
|
794 |
* {@code name} algorithm.
|
|
|
795 |
*
|
|
|
796 |
* @param name Name of random number generator algorithm
|
|
|
797 |
*
|
|
|
798 |
* @return An instance of {@link StreamableGenerator}
|
|
|
799 |
*/
|
|
|
800 |
public static StreamableGenerator of(String name) {
|
|
|
801 |
Objects.requireNonNull(name);
|
|
|
802 |
return RandomGeneratorFactory.of(name, StreamableGenerator.class);
|
|
|
803 |
}
|
|
|
804 |
|
|
|
805 |
/**
|
|
|
806 |
* Returns an instance of {@link StreamableGenerator} that utilizes the
|
|
|
807 |
* specified {@code algorithm}.
|
|
|
808 |
*
|
|
|
809 |
* @param algorithm Random number generator algorithm
|
|
|
810 |
*
|
|
|
811 |
* @return An instance of {@link StreamableGenerator}
|
|
|
812 |
*/
|
|
|
813 |
public static StreamableGenerator of(Algorithm algorithm) {
|
|
|
814 |
Objects.requireNonNull(algorithm);
|
|
|
815 |
return RandomGeneratorFactory.of(algorithm.toString(), StreamableGenerator.class);
|
|
|
816 |
}
|
|
|
817 |
|
|
|
818 |
/**
|
|
|
819 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
820 |
* of {@link StreamableGenerator} that utilizes the {@code name} algorithm.
|
|
|
821 |
*
|
|
|
822 |
* @param name Name of random number generator algorithm
|
|
|
823 |
*
|
|
|
824 |
* @return Factory of {@link StreamableGenerator}
|
|
|
825 |
*/
|
|
|
826 |
public static RandomGeneratorFactory<StreamableGenerator> factoryOf(String name) {
|
|
|
827 |
Objects.requireNonNull(name);
|
|
|
828 |
return RandomGeneratorFactory.factoryOf(name, StreamableGenerator.class);
|
|
|
829 |
}
|
|
|
830 |
|
|
|
831 |
/**
|
|
|
832 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
833 |
* of {@link StreamableGenerator} that utilizes the specified {@code algorithm}.
|
|
|
834 |
*
|
|
|
835 |
* @param algorithm Random number generator algorithm
|
|
|
836 |
*
|
|
|
837 |
* @return Factory of {@link StreamableGenerator}
|
|
|
838 |
*/
|
|
|
839 |
public static RandomGeneratorFactory<StreamableGenerator> factoryOf(Algorithm algorithm) {
|
|
|
840 |
Objects.requireNonNull(algorithm);
|
|
|
841 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), StreamableGenerator.class);
|
|
|
842 |
}
|
|
|
843 |
|
|
57547
|
844 |
/**
|
|
|
845 |
* Returns an effectively unlimited stream of objects, each of
|
|
|
846 |
* which implements the {@link RandomGenerator} interface. Ideally the
|
|
|
847 |
* generators in the stream will appear to be statistically
|
|
|
848 |
* independent. The new generators should be of the same kind
|
|
|
849 |
* as this generator.
|
|
|
850 |
*
|
|
|
851 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
852 |
*
|
|
|
853 |
* @implNote It is permitted to implement this method in a manner
|
|
|
854 |
* equivalent to {@code rngs(Long.MAX_VALUE)}.
|
|
|
855 |
*/
|
|
|
856 |
Stream<RandomGenerator> rngs();
|
|
|
857 |
|
|
|
858 |
/**
|
|
|
859 |
* Returns an effectively unlimited stream of objects, each of
|
|
|
860 |
* which implements the {@link RandomGenerator} interface. Ideally the
|
|
|
861 |
* generators in the stream will appear to be statistically
|
|
|
862 |
* independent. The new generators should be of the same kind
|
|
|
863 |
* as this generator.
|
|
|
864 |
*
|
|
|
865 |
* @param streamSize the number of generators to generate
|
|
|
866 |
*
|
|
|
867 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
868 |
*
|
|
|
869 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
870 |
* less than zero
|
|
|
871 |
*
|
|
|
872 |
* @implNote The default implementation calls {@code rngs()} and
|
|
|
873 |
* then limits its length to {@code streamSize}.
|
|
|
874 |
*/
|
|
|
875 |
default Stream<RandomGenerator> rngs(long streamSize) {
|
|
|
876 |
RandomSupport.checkStreamSize(streamSize);
|
|
|
877 |
return rngs().limit(streamSize);
|
|
|
878 |
}
|
|
|
879 |
}
|
|
|
880 |
|
|
|
881 |
/**
|
|
|
882 |
* This interface is designed to provide a common protocol for objects
|
|
|
883 |
* that generate sequences of pseudorandom numbers (or Boolean values)
|
|
|
884 |
* and furthermore can be <i>split</i> into two objects (the original
|
|
|
885 |
* one and a new one) each of which obey that same protocol (and therefore
|
|
|
886 |
* can be recursively split indefinitely).
|
|
|
887 |
* <p>
|
|
|
888 |
* Ideally, all {@link SplittableGenerator} objects produced by recursive
|
|
|
889 |
* splitting from a single original {@link SplittableGenerator} object are
|
|
|
890 |
* statistically independent of one another and individually uniform.
|
|
|
891 |
* Therefore we would expect the set of values collectively generated
|
|
|
892 |
* by a set of such objects to have the same statistical properties as
|
|
|
893 |
* if the same quantity of values were generated by a single thread
|
|
|
894 |
* using a single {@link SplittableGenerator} object. In practice, one must
|
|
|
895 |
* settle for some approximation to independence and uniformity.
|
|
|
896 |
* <p>
|
|
|
897 |
* Methods are provided to perform a single splitting operation and
|
|
|
898 |
* also to produce a stream of generators split off from the original
|
|
|
899 |
* (by either iterative or recursive splitting, or a combination).
|
|
|
900 |
* <p>
|
|
|
901 |
* An implementation of the {@link SplittableGenerator} interface must provide
|
|
|
902 |
* concrete definitions for the methods {@code nextInt()}, {@code nextLong},
|
|
|
903 |
* {@code period()}, {@code split()}, {@code split(SplittableGenerator)},
|
|
|
904 |
* {@code splits()}, {@code splits(long)}, {@code splits(SplittableGenerator)},
|
|
|
905 |
* and {@code splits(long, SplittableGenerator)}. Perhaps the most convenient
|
|
|
906 |
* way to implement this interface is to extend the abstract class
|
|
|
907 |
* {@link AbstractSplittableGenerator}.
|
|
|
908 |
* <p>
|
|
|
909 |
* Objects that implement {@link SplittableGenerator} are
|
|
|
910 |
* typically not cryptographically secure. Consider instead using
|
|
|
911 |
* {@link java.security.SecureRandom} to get a cryptographically
|
|
|
912 |
* secure pseudo-random number generator for use by
|
|
|
913 |
* security-sensitive applications.
|
|
|
914 |
*
|
|
|
915 |
* @since 14
|
|
|
916 |
*/
|
|
|
917 |
public interface SplittableGenerator extends StreamableGenerator {
|
|
|
918 |
|
|
|
919 |
/**
|
|
57671
|
920 |
* Returns an instance of {@link SplittableGenerator} that utilizes the
|
|
|
921 |
* {@code name} algorithm.
|
|
|
922 |
*
|
|
|
923 |
* @param name Name of random number generator algorithm
|
|
|
924 |
*
|
|
|
925 |
* @return An instance of {@link SplittableGenerator}
|
|
|
926 |
*/
|
|
|
927 |
public static SplittableGenerator of(String name) {
|
|
|
928 |
Objects.requireNonNull(name);
|
|
|
929 |
return RandomGeneratorFactory.of(name, SplittableGenerator.class);
|
|
|
930 |
}
|
|
|
931 |
|
|
|
932 |
/**
|
|
|
933 |
* Returns an instance of {@link SplittableGenerator} that utilizes the
|
|
|
934 |
* specified {@code algorithm}.
|
|
|
935 |
*
|
|
|
936 |
* @param algorithm Random number generator algorithm
|
|
|
937 |
*
|
|
|
938 |
* @return An instance of {@link SplittableGenerator}
|
|
|
939 |
*/
|
|
|
940 |
public static SplittableGenerator of(Algorithm algorithm) {
|
|
|
941 |
Objects.requireNonNull(algorithm);
|
|
|
942 |
return RandomGeneratorFactory.of(algorithm.toString(), SplittableGenerator.class);
|
|
|
943 |
}
|
|
|
944 |
|
|
|
945 |
/**
|
|
|
946 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
947 |
* of {@link SplittableGenerator} that utilizes the {@code name} algorithm.
|
|
|
948 |
*
|
|
|
949 |
* @param name Name of random number generator algorithm
|
|
|
950 |
*
|
|
|
951 |
* @return Factory of {@link SplittableGenerator}
|
|
|
952 |
*/
|
|
|
953 |
public static RandomGeneratorFactory<SplittableGenerator> factoryOf(String name) {
|
|
|
954 |
Objects.requireNonNull(name);
|
|
|
955 |
return RandomGeneratorFactory.factoryOf(name, SplittableGenerator.class);
|
|
|
956 |
}
|
|
|
957 |
|
|
|
958 |
/**
|
|
|
959 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
960 |
* of {@link SplittableGenerator} that utilizes the specified {@code algorithm}.
|
|
|
961 |
*
|
|
|
962 |
* @param algorithm Random number generator algorithm
|
|
|
963 |
*
|
|
|
964 |
* @return Factory of {@link SplittableGenerator}
|
|
|
965 |
*/
|
|
|
966 |
public static RandomGeneratorFactory<SplittableGenerator> factoryOf(Algorithm algorithm) {
|
|
|
967 |
Objects.requireNonNull(algorithm);
|
|
|
968 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), SplittableGenerator.class);
|
|
|
969 |
}
|
|
|
970 |
|
|
|
971 |
/**
|
|
57547
|
972 |
* Returns a new pseudorandom number generator, split off from
|
|
|
973 |
* this one, that implements the {@link RandomGenerator} and {@link SplittableGenerator}
|
|
|
974 |
* interfaces.
|
|
|
975 |
*
|
|
|
976 |
* This pseudorandom number generator may be used as a source of
|
|
|
977 |
* pseudorandom bits used to initialize the state the new one.
|
|
|
978 |
*
|
|
|
979 |
* @return a new object that implements the {@link RandomGenerator} and
|
|
|
980 |
* {@link SplittableGenerator} interfaces
|
|
|
981 |
*/
|
|
|
982 |
SplittableGenerator split();
|
|
|
983 |
|
|
|
984 |
/**
|
|
|
985 |
* Returns a new pseudorandom number generator, split off from
|
|
|
986 |
* this one, that implements the {@link RandomGenerator} and {@link SplittableGenerator}
|
|
|
987 |
* interfaces.
|
|
|
988 |
*
|
|
|
989 |
* @param source a {@link SplittableGenerator} instance to be used instead
|
|
|
990 |
* of this one as a source of pseudorandom bits used to
|
|
|
991 |
* initialize the state of the new ones.
|
|
|
992 |
*
|
|
|
993 |
* @return an object that implements the {@link RandomGenerator} and
|
|
|
994 |
* {@link SplittableGenerator} interfaces
|
|
|
995 |
*/
|
|
|
996 |
SplittableGenerator split(SplittableGenerator source);
|
|
|
997 |
|
|
|
998 |
/**
|
|
|
999 |
* Returns an effectively unlimited stream of new pseudorandom
|
|
|
1000 |
* number generators, each of which implements the {@link SplittableGenerator}
|
|
|
1001 |
* interface.
|
|
|
1002 |
*
|
|
|
1003 |
* This pseudorandom number generator may be used as a source of
|
|
|
1004 |
* pseudorandom bits used to initialize the state the new ones.
|
|
|
1005 |
*
|
|
|
1006 |
* @implNote It is permitted to implement this method in a manner
|
|
|
1007 |
* equivalent to {@code splits(Long.MAX_VALUE)}.
|
|
|
1008 |
*
|
|
|
1009 |
* @return a stream of {@link SplittableGenerator} objects
|
|
|
1010 |
*/
|
|
|
1011 |
default Stream<SplittableGenerator> splits() {
|
|
|
1012 |
return this.splits(this);
|
|
|
1013 |
}
|
|
|
1014 |
|
|
|
1015 |
/**
|
|
|
1016 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
1017 |
* new pseudorandom number generators, each of which implements the
|
|
|
1018 |
* {@link SplittableGenerator} interface.
|
|
|
1019 |
*
|
|
|
1020 |
* This pseudorandom number generator may be used as a source of
|
|
|
1021 |
* pseudorandom bits used to initialize the state the new ones.
|
|
|
1022 |
*
|
|
|
1023 |
* @param streamSize the number of values to generate
|
|
|
1024 |
*
|
|
|
1025 |
* @return a stream of {@link SplittableGenerator} objects
|
|
|
1026 |
*
|
|
|
1027 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
1028 |
* less than zero
|
|
|
1029 |
*/
|
|
|
1030 |
Stream<SplittableGenerator> splits(long streamSize);
|
|
|
1031 |
|
|
|
1032 |
/**
|
|
|
1033 |
* Returns an effectively unlimited stream of new pseudorandom
|
|
|
1034 |
* number generators, each of which implements the {@link SplittableGenerator}
|
|
|
1035 |
* interface.
|
|
|
1036 |
*
|
|
|
1037 |
* @param source a {@link SplittableGenerator} instance to be used instead
|
|
|
1038 |
* of this one as a source of pseudorandom bits used to
|
|
|
1039 |
* initialize the state of the new ones.
|
|
|
1040 |
*
|
|
|
1041 |
* @return a stream of {@link SplittableGenerator} objects
|
|
|
1042 |
*
|
|
|
1043 |
* @implNote It is permitted to implement this method in a manner
|
|
|
1044 |
* equivalent to {@code splits(Long.MAX_VALUE, source)}.
|
|
|
1045 |
*/
|
|
|
1046 |
Stream<SplittableGenerator> splits(SplittableGenerator source);
|
|
|
1047 |
|
|
|
1048 |
/**
|
|
|
1049 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
1050 |
* new pseudorandom number generators, each of which implements the
|
|
|
1051 |
* {@link SplittableGenerator} interface.
|
|
|
1052 |
*
|
|
|
1053 |
* @param streamSize the number of values to generate
|
|
|
1054 |
* @param source a {@link SplittableGenerator} instance to be used instead
|
|
|
1055 |
* of this one as a source of pseudorandom bits used to
|
|
|
1056 |
* initialize the state of the new ones.
|
|
|
1057 |
*
|
|
|
1058 |
* @return a stream of {@link SplittableGenerator} objects
|
|
|
1059 |
*
|
|
|
1060 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
1061 |
* less than zero
|
|
|
1062 |
*/
|
|
|
1063 |
Stream<SplittableGenerator> splits(long streamSize, SplittableGenerator source);
|
|
|
1064 |
|
|
|
1065 |
/**
|
|
|
1066 |
* Returns an effectively unlimited stream of new pseudorandom
|
|
|
1067 |
* number generators, each of which implements the {@link RandomGenerator}
|
|
|
1068 |
* interface. Ideally the generators in the stream will appear
|
|
|
1069 |
* to be statistically independent.
|
|
|
1070 |
*
|
|
|
1071 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1072 |
*
|
|
|
1073 |
* @implNote The default implementation calls {@code splits()}.
|
|
|
1074 |
*/
|
|
|
1075 |
default Stream<RandomGenerator> rngs() {
|
|
|
1076 |
return this.splits().map(x -> (RandomGenerator)x);
|
|
|
1077 |
}
|
|
|
1078 |
|
|
|
1079 |
/**
|
|
|
1080 |
* Returns a stream producing the given {@code streamSize} number of
|
|
|
1081 |
* new pseudorandom number generators, each of which implements the
|
|
|
1082 |
* {@link RandomGenerator} interface. Ideally the generators in the stream will
|
|
|
1083 |
* appear to be statistically independent.
|
|
|
1084 |
*
|
|
|
1085 |
* @param streamSize the number of generators to generate
|
|
|
1086 |
*
|
|
|
1087 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1088 |
*
|
|
|
1089 |
* @throws IllegalArgumentException if {@code streamSize} is
|
|
|
1090 |
* less than zero
|
|
|
1091 |
*
|
|
|
1092 |
* @implNote The default implementation calls {@code splits(streamSize)}.
|
|
|
1093 |
*/
|
|
|
1094 |
default Stream<RandomGenerator> rngs(long streamSize) {
|
|
|
1095 |
return this.splits(streamSize).map(x -> (RandomGenerator)x);
|
|
|
1096 |
}
|
|
|
1097 |
}
|
|
|
1098 |
|
|
|
1099 |
/**
|
|
|
1100 |
* This interface is designed to provide a common protocol for objects that generate pseudorandom
|
|
|
1101 |
* sequences of numbers (or Boolean values) and furthermore can easily <i>jump</i> forward (by a
|
|
|
1102 |
* fixed amount) to a distant point in the state cycle.
|
|
|
1103 |
* <p>
|
|
|
1104 |
* Ideally, all {@link JumpableGenerator} objects produced by iterative jumping from a single original
|
|
|
1105 |
* {@link JumpableGenerator} object are statistically independent of one another and individually uniform.
|
|
|
1106 |
* In practice, one must settle for some approximation to independence and uniformity. In
|
|
|
1107 |
* particular, a specific implementation may assume that each generator in a stream produced by the
|
|
|
1108 |
* {@code jumps} method is used to produce a number of values no larger than either 2<sup>64</sup>
|
|
|
1109 |
* or the square root of its period. Implementors are advised to use algorithms whose period is at
|
|
|
1110 |
* least 2<sup>127</sup>.
|
|
|
1111 |
* <p>
|
|
|
1112 |
* Methods are provided to perform a single jump operation and also to produce a stream of
|
|
|
1113 |
* generators produced from the original by iterative copying and jumping of internal state. A
|
|
|
1114 |
* typical strategy for a multithreaded application is to create a single {@link JumpableGenerator}
|
|
|
1115 |
* object, calls its {@code jumps} method exactly once, and then parcel out generators from the
|
|
|
1116 |
* resulting stream, one to each thread. It is generally not a good idea to call {@code jump} on a
|
|
|
1117 |
* generator that was itself produced by the {@code jumps} method, because the result may be a
|
|
|
1118 |
* generator identical to another generator already produce by that call to the {@code jumps}
|
|
|
1119 |
* method. For this reason, the return type of the {@code jumps} method is {@code
|
|
|
1120 |
* Stream<RandomGenerator>} rather than {@code Stream<JumpableGenerator>}, even though the actual
|
|
|
1121 |
* generator objects in that stream likely do also implement the {@link JumpableGenerator} interface.
|
|
|
1122 |
* <p>
|
|
|
1123 |
* An implementation of the {@link JumpableGenerator} interface must provide concrete definitions for the
|
|
|
1124 |
* methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code copy()}, {@code jump()},
|
|
|
1125 |
* and {@code defaultJumpDistance()}. Default implementations are provided for all other methods.
|
|
|
1126 |
* <p>
|
|
|
1127 |
* Objects that implement {@link JumpableGenerator} are typically not cryptographically secure. Consider
|
|
|
1128 |
* instead using {@link java.security.SecureRandom} to get a cryptographically secure pseudo-random
|
|
|
1129 |
* number generator for use by security-sensitive applications.
|
|
|
1130 |
*
|
|
|
1131 |
* @since 14
|
|
|
1132 |
*/
|
|
|
1133 |
public interface JumpableGenerator extends StreamableGenerator {
|
|
57671
|
1134 |
|
|
|
1135 |
/**
|
|
|
1136 |
* Returns an instance of {@link JumpableGenerator} that utilizes the
|
|
|
1137 |
* {@code name} algorithm.
|
|
|
1138 |
*
|
|
|
1139 |
* @param name Name of random number generator algorithm
|
|
|
1140 |
*
|
|
|
1141 |
* @return An instance of {@link JumpableGenerator}
|
|
|
1142 |
*/
|
|
|
1143 |
public static JumpableGenerator of(String name) {
|
|
|
1144 |
Objects.requireNonNull(name);
|
|
|
1145 |
return RandomGeneratorFactory.of(name, JumpableGenerator.class);
|
|
|
1146 |
}
|
|
|
1147 |
|
|
|
1148 |
/**
|
|
|
1149 |
* Returns an instance of {@link JumpableGenerator} that utilizes the
|
|
|
1150 |
* specified {@code algorithm}.
|
|
|
1151 |
*
|
|
|
1152 |
* @param algorithm Random number generator algorithm
|
|
|
1153 |
*
|
|
|
1154 |
* @return An instance of {@link JumpableGenerator}
|
|
|
1155 |
*/
|
|
|
1156 |
public static JumpableGenerator of(Algorithm algorithm) {
|
|
|
1157 |
Objects.requireNonNull(algorithm);
|
|
|
1158 |
return RandomGeneratorFactory.of(algorithm.toString(), JumpableGenerator.class);
|
|
|
1159 |
}
|
|
|
1160 |
|
|
|
1161 |
/**
|
|
|
1162 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1163 |
* of {@link JumpableGenerator} that utilizes the {@code name} algorithm.
|
|
|
1164 |
*
|
|
|
1165 |
* @param name Name of random number generator algorithm
|
|
|
1166 |
*
|
|
|
1167 |
* @return Factory of {@link JumpableGenerator}
|
|
|
1168 |
*/
|
|
|
1169 |
public static RandomGeneratorFactory<JumpableGenerator> factoryOf(String name) {
|
|
|
1170 |
Objects.requireNonNull(name);
|
|
|
1171 |
return RandomGeneratorFactory.factoryOf(name, JumpableGenerator.class);
|
|
|
1172 |
}
|
|
|
1173 |
|
|
|
1174 |
/**
|
|
|
1175 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1176 |
* of {@link JumpableGenerator} that utilizes the specified {@code algorithm}.
|
|
|
1177 |
*
|
|
|
1178 |
* @param algorithm Random number generator algorithm
|
|
|
1179 |
*
|
|
|
1180 |
* @return Factory of {@link JumpableGenerator}
|
|
|
1181 |
*/
|
|
|
1182 |
public static RandomGeneratorFactory<JumpableGenerator> factoryOf(Algorithm algorithm) {
|
|
|
1183 |
Objects.requireNonNull(algorithm);
|
|
|
1184 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), JumpableGenerator.class);
|
|
|
1185 |
}
|
|
|
1186 |
|
|
57547
|
1187 |
/**
|
|
|
1188 |
* Returns a new generator whose internal state is an exact copy of this generator (therefore
|
|
|
1189 |
* their future behavior should be identical if subjected to the same series of operations).
|
|
|
1190 |
*
|
|
|
1191 |
* @return a new object that is a copy of this generator
|
|
|
1192 |
*/
|
|
|
1193 |
JumpableGenerator copy();
|
|
|
1194 |
|
|
|
1195 |
/**
|
|
|
1196 |
* Alter the state of this pseudorandom number generator so as to jump forward a large, fixed
|
|
|
1197 |
* distance (typically 2<sup>64</sup> or more) within its state cycle.
|
|
|
1198 |
*/
|
|
|
1199 |
void jump();
|
|
|
1200 |
|
|
|
1201 |
/**
|
|
|
1202 |
* Returns the distance by which the {@code jump()} method will jump forward within the state
|
|
|
1203 |
* cycle of this generator object.
|
|
|
1204 |
*
|
|
|
1205 |
* @return the default jump distance (as a {@code double} value)
|
|
|
1206 |
*/
|
|
|
1207 |
double defaultJumpDistance();
|
|
|
1208 |
|
|
|
1209 |
/**
|
|
|
1210 |
* Returns an effectively unlimited stream of new pseudorandom number generators, each of which
|
|
|
1211 |
* implements the {@link RandomGenerator} interface.
|
|
|
1212 |
*
|
|
|
1213 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1214 |
*
|
|
|
1215 |
* @implNote It is permitted to implement this method in a manner equivalent to
|
|
|
1216 |
* {@code jumps(Long.MAX_VALUE)}.
|
|
|
1217 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
1218 |
* calls {@code copy()} and {@code jump()} on this generator, and the copies become the
|
|
|
1219 |
* generators produced by the stream.
|
|
|
1220 |
*/
|
|
|
1221 |
default Stream<RandomGenerator> jumps() {
|
|
|
1222 |
return Stream.generate(this::copyAndJump).sequential();
|
|
|
1223 |
}
|
|
|
1224 |
|
|
|
1225 |
/**
|
|
|
1226 |
* Returns a stream producing the given {@code streamSize} number of new pseudorandom number
|
|
|
1227 |
* generators, each of which implements the {@link RandomGenerator} interface.
|
|
|
1228 |
*
|
|
|
1229 |
* @param streamSize the number of generators to generate
|
|
|
1230 |
*
|
|
|
1231 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1232 |
*
|
|
|
1233 |
* @throws IllegalArgumentException if {@code streamSize} is less than zero
|
|
|
1234 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
1235 |
* calls {@code copy()} and {@code jump()} on this generator, and the copies become the
|
|
|
1236 |
* generators produced by the stream.
|
|
|
1237 |
*/
|
|
|
1238 |
default Stream<RandomGenerator> jumps(long streamSize) {
|
|
|
1239 |
return jumps().limit(streamSize);
|
|
|
1240 |
}
|
|
|
1241 |
|
|
|
1242 |
/**
|
|
|
1243 |
* Returns an effectively unlimited stream of new pseudorandom number generators, each of which
|
|
|
1244 |
* implements the {@link RandomGenerator} interface. Ideally the generators in the stream
|
|
|
1245 |
* will appear to be statistically independent.
|
|
|
1246 |
*
|
|
|
1247 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1248 |
*
|
|
|
1249 |
* @implNote The default implementation calls {@code jumps()}.
|
|
|
1250 |
*/
|
|
|
1251 |
default Stream<RandomGenerator> rngs() {
|
|
|
1252 |
return this.jumps();
|
|
|
1253 |
}
|
|
|
1254 |
|
|
|
1255 |
/**
|
|
|
1256 |
* Returns a stream producing the given {@code streamSize} number of new pseudorandom number
|
|
|
1257 |
* generators, each of which implements the {@link RandomGenerator} interface. Ideally
|
|
|
1258 |
* the generators in the stream will appear to be statistically independent.
|
|
|
1259 |
*
|
|
|
1260 |
* @param streamSize the number of generators to generate
|
|
|
1261 |
*
|
|
|
1262 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1263 |
*
|
|
|
1264 |
* @throws IllegalArgumentException if {@code streamSize} is less than zero
|
|
|
1265 |
* @implNote The default implementation calls {@code jumps(streamSize)}.
|
|
|
1266 |
*/
|
|
|
1267 |
default Stream<RandomGenerator> rngs(long streamSize) {
|
|
|
1268 |
return this.jumps(streamSize);
|
|
|
1269 |
}
|
|
|
1270 |
|
|
|
1271 |
/**
|
|
|
1272 |
* Copy this generator, jump this generator forward, then return the copy.
|
|
|
1273 |
*
|
|
|
1274 |
* @return a copy of this generator object before the jump occurred
|
|
|
1275 |
*/
|
|
|
1276 |
default RandomGenerator copyAndJump() {
|
|
|
1277 |
RandomGenerator result = copy();
|
|
|
1278 |
jump();
|
|
|
1279 |
return result;
|
|
|
1280 |
}
|
|
|
1281 |
|
|
|
1282 |
}
|
|
|
1283 |
|
|
|
1284 |
/**
|
|
|
1285 |
* This interface is designed to provide a common protocol for objects that generate sequences of
|
|
|
1286 |
* pseudorandom numbers (or Boolean values) and furthermore can easily not only jump but also
|
|
|
1287 |
* <i>leap</i> to a very distant point in the state cycle.
|
|
|
1288 |
* <p>
|
|
|
1289 |
* Typically one will construct a series of {@link LeapableGenerator} objects by iterative leaping from a
|
|
|
1290 |
* single original {@link LeapableGenerator} object, and then for each such object produce a subseries of
|
|
|
1291 |
* objects by iterative jumping. There is little conceptual difference between leaping and jumping,
|
|
|
1292 |
* but typically a leap will be a very long jump in the state cycle (perhaps distance
|
|
|
1293 |
* 2<sup>128</sup> or so).
|
|
|
1294 |
* <p>
|
|
|
1295 |
* Ideally, all {@link LeapableGenerator} objects produced by iterative leaping and jumping from a single
|
|
|
1296 |
* original {@link LeapableGenerator} object are statistically independent of one another and individually
|
|
|
1297 |
* uniform. In practice, one must settle for some approximation to independence and uniformity. In
|
|
|
1298 |
* particular, a specific implementation may assume that each generator in a stream produced by the
|
|
|
1299 |
* {@code leaps} method is used to produce (by jumping) a number of objects no larger than
|
|
|
1300 |
* 2<sup>64</sup>. Implementors are advised to use algorithms whose period is at least
|
|
|
1301 |
* 2<sup>191</sup>.
|
|
|
1302 |
* <p>
|
|
|
1303 |
* Methods are provided to perform a single leap operation and also to produce a stream of
|
|
|
1304 |
* generators produced from the original by iterative copying and leaping of internal state. The
|
|
|
1305 |
* generators produced must implement the {@link JumpableGenerator} interface but need not also implement
|
|
|
1306 |
* the {@link LeapableGenerator} interface. A typical strategy for a multithreaded application is to
|
|
|
1307 |
* create a single {@link LeapableGenerator} object, calls its {@code leaps} method exactly once, and then
|
|
|
1308 |
* parcel out generators from the resulting stream, one to each thread. Then the {@code jumps}
|
|
|
1309 |
* method of each such generator be called to produce a substream of generator objects.
|
|
|
1310 |
* <p>
|
|
|
1311 |
* An implementation of the {@link LeapableGenerator} interface must provide concrete definitions for the
|
|
|
1312 |
* methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code copy()}, {@code jump()},
|
|
|
1313 |
* {@code defaultJumpDistance()}, {@code leap()}, and {@code defaultLeapDistance()}. Default
|
|
|
1314 |
* implementations are provided for all other methods.
|
|
|
1315 |
* <p>
|
|
|
1316 |
* Objects that implement {@link LeapableGenerator} are typically not cryptographically secure. Consider
|
|
|
1317 |
* instead using {@link java.security.SecureRandom} to get a cryptographically secure pseudo-random
|
|
|
1318 |
* number generator for use by security-sensitive applications.
|
|
|
1319 |
*
|
|
|
1320 |
* @since 14
|
|
|
1321 |
*/
|
|
|
1322 |
public interface LeapableGenerator extends JumpableGenerator {
|
|
57671
|
1323 |
|
|
|
1324 |
/**
|
|
|
1325 |
* Returns an instance of {@link LeapableGenerator} that utilizes the
|
|
|
1326 |
* {@code name} algorithm.
|
|
|
1327 |
*
|
|
|
1328 |
* @param name Name of random number generator algorithm
|
|
|
1329 |
*
|
|
|
1330 |
* @return An instance of {@link LeapableGenerator}
|
|
|
1331 |
*/
|
|
|
1332 |
public static LeapableGenerator of(String name) {
|
|
|
1333 |
Objects.requireNonNull(name);
|
|
|
1334 |
return RandomGeneratorFactory.of(name, LeapableGenerator.class);
|
|
|
1335 |
}
|
|
|
1336 |
|
|
|
1337 |
/**
|
|
|
1338 |
* Returns an instance of {@link LeapableGenerator} that utilizes the
|
|
|
1339 |
* specified {@code algorithm}.
|
|
|
1340 |
*
|
|
|
1341 |
* @param algorithm Random number generator algorithm
|
|
|
1342 |
*
|
|
|
1343 |
* @return An instance of {@link LeapableGenerator}
|
|
|
1344 |
*/
|
|
|
1345 |
public static LeapableGenerator of(Algorithm algorithm) {
|
|
|
1346 |
Objects.requireNonNull(algorithm);
|
|
|
1347 |
return RandomGeneratorFactory.of(algorithm.toString(), LeapableGenerator.class);
|
|
|
1348 |
}
|
|
|
1349 |
|
|
|
1350 |
/**
|
|
|
1351 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1352 |
* of {@link LeapableGenerator} that utilizes the {@code name} algorithm.
|
|
|
1353 |
*
|
|
|
1354 |
* @param name Name of random number generator algorithm
|
|
|
1355 |
*
|
|
|
1356 |
* @return Factory of {@link LeapableGenerator}
|
|
|
1357 |
*/
|
|
|
1358 |
public static RandomGeneratorFactory<LeapableGenerator> factoryOf(String name) {
|
|
|
1359 |
Objects.requireNonNull(name);
|
|
|
1360 |
return RandomGeneratorFactory.factoryOf(name, LeapableGenerator.class);
|
|
|
1361 |
}
|
|
|
1362 |
|
|
|
1363 |
/**
|
|
|
1364 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1365 |
* of {@link LeapableGenerator} that utilizes the specified {@code algorithm}.
|
|
|
1366 |
*
|
|
|
1367 |
* @param algorithm Random number generator algorithm
|
|
|
1368 |
*
|
|
|
1369 |
* @return Factory of {@link LeapableGenerator}
|
|
|
1370 |
*/
|
|
|
1371 |
public static RandomGeneratorFactory<LeapableGenerator> factoryOf(Algorithm algorithm) {
|
|
|
1372 |
Objects.requireNonNull(algorithm);
|
|
|
1373 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), LeapableGenerator.class);
|
|
|
1374 |
}
|
|
|
1375 |
|
|
57547
|
1376 |
/**
|
|
|
1377 |
* Returns a new generator whose internal state is an exact copy of this generator (therefore
|
|
|
1378 |
* their future behavior should be identical if subjected to the same series of operations).
|
|
|
1379 |
*
|
|
|
1380 |
* @return a new object that is a copy of this generator
|
|
|
1381 |
*/
|
|
|
1382 |
LeapableGenerator copy();
|
|
|
1383 |
|
|
|
1384 |
/**
|
|
|
1385 |
* Alter the state of this pseudorandom number generator so as to leap forward a large, fixed
|
|
|
1386 |
* distance (typically 2<sup>96</sup> or more) within its state cycle.
|
|
|
1387 |
*/
|
|
|
1388 |
void leap();
|
|
|
1389 |
|
|
|
1390 |
/**
|
|
|
1391 |
* Returns the distance by which the {@code leap()} method will leap forward within the state
|
|
|
1392 |
* cycle of this generator object.
|
|
|
1393 |
*
|
|
|
1394 |
* @return the default leap distance (as a {@code double} value)
|
|
|
1395 |
*/
|
|
|
1396 |
double defaultLeapDistance();
|
|
|
1397 |
|
|
|
1398 |
/**
|
|
|
1399 |
* Returns an effectively unlimited stream of new pseudorandom number generators, each of which
|
|
|
1400 |
* implements the {@link JumpableGenerator} interface.
|
|
|
1401 |
*
|
|
|
1402 |
* @return a stream of objects that implement the {@link JumpableGenerator} interface
|
|
|
1403 |
*
|
|
|
1404 |
* @implNote It is permitted to implement this method in a manner equivalent to {@code
|
|
|
1405 |
* leaps(Long.MAX_VALUE)}.
|
|
|
1406 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
1407 |
* calls {@code copy()} and {@code leap()} on this generator, and the copies become the
|
|
|
1408 |
* generators produced by the stream.
|
|
|
1409 |
*/
|
|
|
1410 |
default Stream<JumpableGenerator> leaps() {
|
|
|
1411 |
return Stream.generate(this::copyAndLeap).sequential();
|
|
|
1412 |
}
|
|
|
1413 |
|
|
|
1414 |
/**
|
|
|
1415 |
* Returns a stream producing the given {@code streamSize} number of new pseudorandom number
|
|
|
1416 |
* generators, each of which implements the {@link JumpableGenerator} interface.
|
|
|
1417 |
*
|
|
|
1418 |
* @param streamSize the number of generators to generate
|
|
|
1419 |
*
|
|
|
1420 |
* @return a stream of objects that implement the {@link JumpableGenerator} interface
|
|
|
1421 |
*
|
|
|
1422 |
* @throws IllegalArgumentException if {@code streamSize} is less than zero
|
|
|
1423 |
* @implNote The default implementation produces a sequential stream that repeatedly
|
|
|
1424 |
* calls {@code copy()} and {@code leap()} on this generator, and the copies become the
|
|
|
1425 |
* generators produced by the stream.
|
|
|
1426 |
*/
|
|
|
1427 |
default Stream<JumpableGenerator> leaps(long streamSize) {
|
|
|
1428 |
return leaps().limit(streamSize);
|
|
|
1429 |
}
|
|
|
1430 |
|
|
|
1431 |
/**
|
|
|
1432 |
* Copy this generator, leap this generator forward, then return the copy.
|
|
|
1433 |
*
|
|
|
1434 |
* @return a copy of this generator object before the leap occurred
|
|
|
1435 |
*/
|
|
|
1436 |
default JumpableGenerator copyAndLeap() {
|
|
|
1437 |
JumpableGenerator result = copy();
|
|
|
1438 |
leap();
|
|
|
1439 |
return result;
|
|
|
1440 |
}
|
|
|
1441 |
|
|
|
1442 |
}
|
|
|
1443 |
|
|
|
1444 |
/**
|
|
|
1445 |
* This interface is designed to provide a common protocol for objects that generate sequences of
|
|
|
1446 |
* pseudorandom numbers (or Boolean values) and furthermore can easily <i>jump</i> to an arbitrarily
|
|
|
1447 |
* specified distant point in the state cycle.
|
|
|
1448 |
* <p>
|
|
|
1449 |
* Ideally, all {@link ArbitrarilyJumpableGenerator} objects produced by iterative jumping from a single
|
|
|
1450 |
* original {@link ArbitrarilyJumpableGenerator} object are statistically independent of one another and
|
|
|
1451 |
* individually uniform, provided that they do not traverse overlapping portions of the state cycle.
|
|
|
1452 |
* In practice, one must settle for some approximation to independence and uniformity. In
|
|
|
1453 |
* particular, a specific implementation may assume that each generator in a stream produced by the
|
|
|
1454 |
* {@code jumps} method is used to produce a number of values no larger than the jump distance
|
|
|
1455 |
* specified. Implementors are advised to use algorithms whose period is at least 2<sup>127</sup>.
|
|
|
1456 |
* <p>
|
|
|
1457 |
* For many applications, it suffices to jump forward by a power of two or some small multiple of a
|
|
|
1458 |
* power of two, but this power of two may not be representable as a {@code long} value. To avoid
|
|
|
1459 |
* the use of {@link java.math.BigInteger} values as jump distances, {@code double} values are used
|
|
|
1460 |
* instead.
|
|
|
1461 |
* <p>
|
|
|
1462 |
* Methods are provided to perform a single jump operation and also to produce a stream of
|
|
|
1463 |
* generators produced from the original by iterative copying and jumping of internal state. A
|
|
|
1464 |
* typical strategy for a multithreaded application is to create a single {@link
|
|
|
1465 |
* ArbitrarilyJumpableGenerator} object, call its {@code jumps} method exactly once, and then parcel out
|
|
|
1466 |
* generators from the resulting stream, one to each thread. However, each generator produced also
|
|
|
1467 |
* has type {@link ArbitrarilyJumpableGenerator}; with care, different jump distances can be used to
|
|
|
1468 |
* traverse the entire state cycle in various ways.
|
|
|
1469 |
* <p>
|
|
|
1470 |
* An implementation of the {@link ArbitrarilyJumpableGenerator} interface must provide concrete
|
|
|
1471 |
* definitions for the methods {@code nextInt()}, {@code nextLong}, {@code period()}, {@code
|
|
|
1472 |
* copy()}, {@code jump(double)}, {@code defaultJumpDistance()}, and {@code defaultLeapDistance()}.
|
|
|
1473 |
* Default implementations are provided for all other methods. Perhaps the most convenient way to
|
|
|
1474 |
* implement this interface is to extend the abstract class {@link ArbitrarilyJumpableGenerator}, which
|
|
|
1475 |
* provides spliterator-based implementations of the methods {@code ints}, {@code longs}, {@code
|
|
|
1476 |
* doubles}, {@code rngs}, {@code jumps}, and {@code leaps}.
|
|
|
1477 |
* <p>
|
|
|
1478 |
* Objects that implement {@link ArbitrarilyJumpableGenerator} are typically not cryptographically secure.
|
|
|
1479 |
* Consider instead using {@link java.security.SecureRandom} to get a cryptographically secure
|
|
|
1480 |
* pseudo-random number generator for use by security-sensitive applications.
|
|
|
1481 |
*
|
|
|
1482 |
* @since 14
|
|
|
1483 |
*/
|
|
|
1484 |
public interface ArbitrarilyJumpableGenerator extends LeapableGenerator {
|
|
57671
|
1485 |
|
|
|
1486 |
/**
|
|
|
1487 |
* Returns an instance of {@link ArbitrarilyJumpableGenerator} that utilizes the
|
|
|
1488 |
* {@code name} algorithm.
|
|
|
1489 |
*
|
|
|
1490 |
* @param name Name of random number generator algorithm
|
|
|
1491 |
*
|
|
|
1492 |
* @return An instance of {@link ArbitrarilyJumpableGenerator}
|
|
|
1493 |
*/
|
|
|
1494 |
public static ArbitrarilyJumpableGenerator of(String name) {
|
|
|
1495 |
Objects.requireNonNull(name);
|
|
|
1496 |
return RandomGeneratorFactory.of(name, ArbitrarilyJumpableGenerator.class);
|
|
|
1497 |
}
|
|
|
1498 |
|
|
|
1499 |
/**
|
|
|
1500 |
* Returns an instance of {@link ArbitrarilyJumpableGenerator} that utilizes the
|
|
|
1501 |
* specified {@code algorithm}.
|
|
|
1502 |
*
|
|
|
1503 |
* @param algorithm Random number generator algorithm
|
|
|
1504 |
*
|
|
|
1505 |
* @return An instance of {@link ArbitrarilyJumpableGenerator}
|
|
|
1506 |
*/
|
|
|
1507 |
public static ArbitrarilyJumpableGenerator of(Algorithm algorithm) {
|
|
|
1508 |
Objects.requireNonNull(algorithm);
|
|
|
1509 |
return RandomGeneratorFactory.of(algorithm.toString(), ArbitrarilyJumpableGenerator.class);
|
|
|
1510 |
}
|
|
|
1511 |
|
|
|
1512 |
/**
|
|
|
1513 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1514 |
* of {@link ArbitrarilyJumpableGenerator} that utilizes the {@code name} algorithm.
|
|
|
1515 |
*
|
|
|
1516 |
* @param name Name of random number generator algorithm
|
|
|
1517 |
*
|
|
|
1518 |
* @return Factory of {@link ArbitrarilyJumpableGenerator}
|
|
|
1519 |
*/
|
|
|
1520 |
public static RandomGeneratorFactory<ArbitrarilyJumpableGenerator> factoryOf(String name) {
|
|
|
1521 |
Objects.requireNonNull(name);
|
|
|
1522 |
return RandomGeneratorFactory.factoryOf(name, ArbitrarilyJumpableGenerator.class);
|
|
|
1523 |
}
|
|
|
1524 |
|
|
|
1525 |
/**
|
|
|
1526 |
* Returns a {@link RandomGeneratorFactory} that can produce instances
|
|
|
1527 |
* of {@link ArbitrarilyJumpableGenerator} that utilizes the specified {@code algorithm}.
|
|
|
1528 |
*
|
|
|
1529 |
* @param algorithm Random number generator algorithm
|
|
|
1530 |
*
|
|
|
1531 |
* @return Factory of {@link ArbitrarilyJumpableGenerator}
|
|
|
1532 |
*/
|
|
|
1533 |
public static RandomGeneratorFactory<ArbitrarilyJumpableGenerator> factoryOf(Algorithm algorithm) {
|
|
|
1534 |
Objects.requireNonNull(algorithm);
|
|
|
1535 |
return RandomGeneratorFactory.factoryOf(algorithm.toString(), ArbitrarilyJumpableGenerator.class);
|
|
|
1536 |
}
|
|
|
1537 |
|
|
57547
|
1538 |
/**
|
|
|
1539 |
* Returns a new generator whose internal state is an exact copy of this generator (therefore
|
|
|
1540 |
* their future behavior should be identical if subjected to the same series of operations).
|
|
|
1541 |
*
|
|
|
1542 |
* @return a new object that is a copy of this generator
|
|
|
1543 |
*/
|
|
|
1544 |
ArbitrarilyJumpableGenerator copy();
|
|
|
1545 |
|
|
|
1546 |
/**
|
|
|
1547 |
* Alter the state of this pseudorandom number generator so as to jump forward a distance equal
|
|
|
1548 |
* to 2<sup>{@code logDistance}</sup> within its state cycle.
|
|
|
1549 |
*
|
|
|
1550 |
* @param logDistance the base-2 logarithm of the distance to jump forward within the state
|
|
|
1551 |
* cycle
|
|
|
1552 |
*
|
|
|
1553 |
* @throws IllegalArgumentException if {@code logDistance} is NaN or negative, or if
|
|
|
1554 |
* 2<sup>{@code logDistance}</sup> is greater than the period
|
|
|
1555 |
* of this generator
|
|
|
1556 |
*/
|
|
|
1557 |
void jumpPowerOfTwo(int logDistance);
|
|
|
1558 |
|
|
|
1559 |
/**
|
|
|
1560 |
* Alter the state of this pseudorandom number generator so as to jump forward a specified
|
|
|
1561 |
* distance within its state cycle.
|
|
|
1562 |
*
|
|
|
1563 |
* @param distance the distance to jump forward within the state cycle
|
|
|
1564 |
*
|
|
|
1565 |
* @throws IllegalArgumentException if {@code distance} is Nan, negative, or greater than the
|
|
|
1566 |
* period of this generator
|
|
|
1567 |
*/
|
|
|
1568 |
void jump(double distance);
|
|
|
1569 |
|
|
|
1570 |
/**
|
|
|
1571 |
* Alter the state of this pseudorandom number generator so as to jump forward a large, fixed
|
|
|
1572 |
* distance (typically 2<sup>64</sup> or more) within its state cycle. The distance used is
|
|
|
1573 |
* that returned by method {@code defaultJumpDistance()}.
|
|
|
1574 |
*/
|
|
|
1575 |
default void jump() { jump(defaultJumpDistance()); }
|
|
|
1576 |
|
|
|
1577 |
/**
|
|
|
1578 |
* Returns an effectively unlimited stream of new pseudorandom number generators, each of which
|
|
|
1579 |
* implements the {@link ArbitrarilyJumpableGenerator} interface, produced by jumping copies of this
|
|
|
1580 |
* generator by different integer multiples of the specified jump distance.
|
|
|
1581 |
*
|
|
|
1582 |
* @param distance a distance to jump forward within the state cycle
|
|
|
1583 |
*
|
|
|
1584 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1585 |
*
|
|
|
1586 |
* @implNote This method is implemented to be equivalent to {@code jumps(Long.MAX_VALUE)}.
|
|
|
1587 |
*/
|
|
|
1588 |
default Stream<ArbitrarilyJumpableGenerator> jumps(double distance) {
|
|
|
1589 |
return Stream.generate(() -> copyAndJump(distance)).sequential();
|
|
|
1590 |
}
|
|
|
1591 |
|
|
|
1592 |
/**
|
|
|
1593 |
* Returns a stream producing the given {@code streamSize} number of new pseudorandom number
|
|
|
1594 |
* generators, each of which implements the {@link ArbitrarilyJumpableGenerator} interface, produced
|
|
|
1595 |
* by jumping copies of this generator by different integer multiples of the specified jump
|
|
|
1596 |
* distance.
|
|
|
1597 |
*
|
|
|
1598 |
* @param streamSize the number of generators to generate
|
|
|
1599 |
* @param distance a distance to jump forward within the state cycle
|
|
|
1600 |
*
|
|
|
1601 |
* @return a stream of objects that implement the {@link RandomGenerator} interface
|
|
|
1602 |
*
|
|
|
1603 |
* @throws IllegalArgumentException if {@code streamSize} is less than zero
|
|
|
1604 |
*/
|
|
|
1605 |
default Stream<ArbitrarilyJumpableGenerator> jumps(long streamSize, double distance) {
|
|
|
1606 |
return jumps(distance).limit(streamSize);
|
|
|
1607 |
}
|
|
|
1608 |
|
|
|
1609 |
/**
|
|
|
1610 |
* Alter the state of this pseudorandom number generator so as to jump forward a very large,
|
|
|
1611 |
* fixed distance (typically 2<sup>128</sup> or more) within its state cycle. The distance used
|
|
|
1612 |
* is that returned by method {@code defaultJLeapDistance()}.
|
|
|
1613 |
*/
|
|
|
1614 |
default void leap() { jump(defaultLeapDistance()); }
|
|
|
1615 |
|
|
|
1616 |
/**
|
|
|
1617 |
* Copy this generator, jump this generator forward, then return the copy.
|
|
|
1618 |
*
|
|
|
1619 |
* @param distance a distance to jump forward within the state cycle
|
|
|
1620 |
*
|
|
|
1621 |
* @return a copy of this generator object before the jump occurred
|
|
|
1622 |
*/
|
|
|
1623 |
default ArbitrarilyJumpableGenerator copyAndJump(double distance) {
|
|
|
1624 |
ArbitrarilyJumpableGenerator result = copy();
|
|
|
1625 |
jump(distance);
|
|
|
1626 |
return result;
|
|
|
1627 |
}
|
|
|
1628 |
|
|
|
1629 |
}
|
|
|
1630 |
}
|