151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski/* 22c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved. 351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This code is free software; you can redistribute it and/or modify it 651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * under the terms of the GNU General Public License version 2 only, as 751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * published by the Free Software Foundation. Oracle designates this 851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * particular file as subject to the "Classpath" exception as provided 951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * by Oracle in the LICENSE file that accompanied this code. 1051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 1151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This code is distributed in the hope that it will be useful, but WITHOUT 1251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * version 2 for more details (a copy is included in the LICENSE file that 1551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * accompanied this code). 1651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 1751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * You should have received a copy of the GNU General Public License version 1851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 2 along with this work; if not, write to the Free Software Foundation, 1951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 2051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 2151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * or visit www.oracle.com if you need additional information or have any 2351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * questions. 2451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 2551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 2651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskipackage java.util; 2751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskiimport java.io.*; 2851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskiimport java.util.concurrent.atomic.AtomicLong; 292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.function.DoubleConsumer; 302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.function.IntConsumer; 312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.function.LongConsumer; 322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.stream.DoubleStream; 332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.stream.IntStream; 342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.stream.LongStream; 352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kongimport java.util.stream.StreamSupport; 362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 3751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskiimport sun.misc.Unsafe; 3851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 3951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski/** 4051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * An instance of this class is used to generate a stream of 4151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * pseudorandom numbers. The class uses a 48-bit seed, which is 4251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * modified using a linear congruential formula. (See Donald Knuth, 4351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <i>The Art of Computer Programming, Volume 2</i>, Section 3.2.1.) 4451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 4551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * If two instances of {@code Random} are created with the same 4651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * seed, and the same sequence of method calls is made for each, they 4751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * will generate and return identical sequences of numbers. In order to 4851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * guarantee this property, particular algorithms are specified for the 4951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * class {@code Random}. Java implementations must use all the algorithms 5051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * shown here for the class {@code Random}, for the sake of absolute 5151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * portability of Java code. However, subclasses of class {@code Random} 5251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * are permitted to use other algorithms, so long as they adhere to the 5351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * general contracts for all the methods. 5451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 5551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The algorithms implemented by class {@code Random} use a 5651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code protected} utility method that on each invocation can supply 5751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * up to 32 pseudorandomly generated bits. 5851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 5951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Many applications will find the method {@link Math#random} simpler to use. 6051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 6151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>Instances of {@code java.util.Random} are threadsafe. 6251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * However, the concurrent use of the same {@code java.util.Random} 6351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * instance across threads may encounter contention and consequent 6451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * poor performance. Consider instead using 6551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@link java.util.concurrent.ThreadLocalRandom} in multithreaded 6651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * designs. 6751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 6851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>Instances of {@code java.util.Random} are not cryptographically 6951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * secure. Consider instead using {@link java.security.SecureRandom} to 7051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * get a cryptographically secure pseudo-random number generator for use 7151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * by security-sensitive applications. 7251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 7351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @author Frank Yellin 7451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @since 1.0 7551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 7651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskipublic 7751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebskiclass Random implements java.io.Serializable { 7851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** use serialVersionUID from JDK 1.1 for interoperability */ 7951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski static final long serialVersionUID = 3905348978240129619L; 8051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 8151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 8251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The internal state associated with this pseudorandom number generator. 8351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * (The specs for the methods in this class describe the ongoing 8451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * computation of this value.) 8551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 8651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private final AtomicLong seed; 8751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 8851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final long multiplier = 0x5DEECE66DL; 8951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final long addend = 0xBL; 9051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final long mask = (1L << 48) - 1; 9151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0 / (1L << 53) 932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong // IllegalArgumentException messages 952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final String BadBound = "bound must be positive"; 962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final String BadRange = "bound must be greater than origin"; 972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final String BadSize = "size must be non-negative"; 982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 9951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 10051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Creates a new random number generator. This constructor sets 10151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * the seed of the random number generator to a value very likely 10251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * to be distinct from any other invocation of this constructor. 10351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 10451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public Random() { 10551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski this(seedUniquifier() ^ System.nanoTime()); 10651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 10751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 10851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static long seedUniquifier() { 10951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // L'Ecuyer, "Tables of Linear Congruential Generators of 11051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // Different Sizes and Good Lattice Structure", 1999 11151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski for (;;) { 11251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski long current = seedUniquifier.get(); 11351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski long next = current * 181783497276652981L; 11451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski if (seedUniquifier.compareAndSet(current, next)) 11551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return next; 11651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 11751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 11851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 11951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final AtomicLong seedUniquifier 12051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski = new AtomicLong(8682522807148012L); 12151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 12251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 12351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Creates a new random number generator using a single {@code long} seed. 12451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The seed is the initial value of the internal state of the pseudorandom 12551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * number generator which is maintained by method {@link #next}. 12651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 12751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The invocation {@code new Random(seed)} is equivalent to: 12851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 12951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Random rnd = new Random(); 13051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * rnd.setSeed(seed);}</pre> 13151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 13251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @param seed the initial seed 13351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @see #setSeed(long) 13451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 13551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public Random(long seed) { 13651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski if (getClass() == Random.class) 13751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski this.seed = new AtomicLong(initialScramble(seed)); 13851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski else { 13951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // subclass might have overriden setSeed 14051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski this.seed = new AtomicLong(); 14151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski setSeed(seed); 14251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 14351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 14451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 14551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static long initialScramble(long seed) { 14651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return (seed ^ multiplier) & mask; 14751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 14851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 14951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 15051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Sets the seed of this random number generator using a single 15151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code long} seed. The general contract of {@code setSeed} is 15251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * that it alters the state of this random number generator object 15351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * so as to be in exactly the same state as if it had just been 15451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * created with the argument {@code seed} as a seed. The method 15551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code setSeed} is implemented by class {@code Random} by 15651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * atomically updating the seed to 15751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre>{@code (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)}</pre> 15851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * and clearing the {@code haveNextNextGaussian} flag used by {@link 15951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * #nextGaussian}. 16051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 16151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The implementation of {@code setSeed} by class {@code Random} 16251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * happens to use only 48 bits of the given seed. In general, however, 16351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * an overriding method may use all 64 bits of the {@code long} 16451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * argument as a seed value. 16551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 16651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @param seed the initial seed 16751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 16851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski synchronized public void setSeed(long seed) { 16951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski this.seed.set(initialScramble(seed)); 17051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski haveNextNextGaussian = false; 17151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 17251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 17351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 17451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Generates the next pseudorandom number. Subclasses should 17551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * override this, as this is used by all other methods. 17651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 17751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The general contract of {@code next} is that it returns an 17851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code int} value and if the argument {@code bits} is between 17951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code 1} and {@code 32} (inclusive), then that many low-order 18051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * bits of the returned value will be (approximately) independently 18151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * chosen bit values, each of which is (approximately) equally 18251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * likely to be {@code 0} or {@code 1}. The method {@code next} is 18351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * implemented by class {@code Random} by atomically updating the seed to 18451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre>{@code (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1)}</pre> 18551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * and returning 18651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre>{@code (int)(seed >>> (48 - bits))}.</pre> 18751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 18851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This is a linear congruential pseudorandom number generator, as 18951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * defined by D. H. Lehmer and described by Donald E. Knuth in 19051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <i>The Art of Computer Programming,</i> Volume 3: 19151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <i>Seminumerical Algorithms</i>, section 3.2.1. 19251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 19351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @param bits random bits 19451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom value from this random number 19551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * generator's sequence 19651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @since 1.1 19751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 19851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski protected int next(int bits) { 19951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski long oldseed, nextseed; 20051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski AtomicLong seed = this.seed; 20151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski do { 20251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski oldseed = seed.get(); 20351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski nextseed = (oldseed * multiplier + addend) & mask; 20451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } while (!seed.compareAndSet(oldseed, nextseed)); 20551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return (int)(nextseed >>> (48 - bits)); 20651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 20751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 20851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 20951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Generates random bytes and places them into a user-supplied 21051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * byte array. The number of random bytes produced is equal to 21151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * the length of the byte array. 21251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 21351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextBytes} is implemented by class {@code Random} 21451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 21551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 21651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public void nextBytes(byte[] bytes) { 21751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * for (int i = 0; i < bytes.length; ) 21851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * for (int rnd = nextInt(), n = Math.min(bytes.length - i, 4); 21951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * n-- > 0; rnd >>= 8) 22051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * bytes[i++] = (byte)rnd; 22151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 22251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 22351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @param bytes the byte array to fill with random bytes 22451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @throws NullPointerException if the byte array is null 22551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @since 1.1 22651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 22751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public void nextBytes(byte[] bytes) { 22851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski for (int i = 0, len = bytes.length; i < len; ) 22951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski for (int rnd = nextInt(), 23051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski n = Math.min(len - i, Integer.SIZE/Byte.SIZE); 23151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski n-- > 0; rnd >>= Byte.SIZE) 23251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski bytes[i++] = (byte)rnd; 23351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 23451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 23551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 2362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * The form of nextLong used by LongStream Spliterators. If 2372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * origin is greater than bound, acts as unbounded form of 2382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * nextLong, else as bounded form. 2392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 2402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param origin the least value, unless greater than bound 2412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param bound the upper bound (exclusive), must not equal origin 2422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a pseudorandom value 2432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 2442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long internalNextLong(long origin, long bound) { 2452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long r = nextLong(); 2462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (origin < bound) { 2472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long n = bound - origin, m = n - 1; 2482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if ((n & m) == 0L) // power of two 2492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r = (r & m) + origin; 2502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong else if (n > 0L) { // reject over-represented candidates 2512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong for (long u = r >>> 1; // ensure nonnegative 2522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong u + m - (r = u % n) < 0L; // rejection check 2532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong u = nextLong() >>> 1) // retry 2542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong ; 2552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r += origin; 2562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong else { // range not representable as long 2582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong while (r < origin || r >= bound) 2592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r = nextLong(); 2602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return r; 2632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 2652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 2662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * The form of nextInt used by IntStream Spliterators. 2672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * For the unbounded case: uses nextInt(). 2682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * For the bounded case with representable range: uses nextInt(int bound) 2692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * For the bounded case with unrepresentable range: uses nextInt() 2702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 2712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param origin the least value, unless greater than bound 2722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param bound the upper bound (exclusive), must not equal origin 2732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a pseudorandom value 2742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 2752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final int internalNextInt(int origin, int bound) { 2762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (origin < bound) { 2772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong int n = bound - origin; 2782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (n > 0) { 2792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return nextInt(n) + origin; 2802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong else { // range not representable as int 2822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong int r; 2832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong do { 2842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r = nextInt(); 2852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } while (r < origin || r >= bound); 2862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return r; 2872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong else { 2902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return nextInt(); 2912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 2932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 2942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 2952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * The form of nextDouble used by DoubleStream Spliterators. 2962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 2972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param origin the least value, unless greater than bound 2982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param bound the upper bound (exclusive), must not equal origin 2992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a pseudorandom value 3002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 3012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final double internalNextDouble(double origin, double bound) { 3022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong double r = nextDouble(); 3032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (origin < bound) { 3042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r = r * (bound - origin) + origin; 3052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (r >= bound) // correct for rounding 3062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong r = Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1); 3072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 3082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return r; 3092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 3102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 3112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 31251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, uniformly distributed {@code int} 31351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value from this random number generator's sequence. The general 31451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * contract of {@code nextInt} is that one {@code int} value is 31537db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * pseudorandomly generated and returned. All 2<sup>32</sup> possible 31637db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * {@code int} values are produced with (approximately) equal probability. 31751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 31851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextInt} is implemented by class {@code Random} 31951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 32051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 32151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public int nextInt() { 32251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return next(32); 32351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 32451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 32551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed {@code int} 32651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value from this random number generator's sequence 32751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 32851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public int nextInt() { 32951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return next(32); 33051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 33151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 33251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 33351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns a pseudorandom, uniformly distributed {@code int} value 33451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * between 0 (inclusive) and the specified value (exclusive), drawn from 33551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * this random number generator's sequence. The general contract of 33651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code nextInt} is that one {@code int} value in the specified range 33737db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * is pseudorandomly generated and returned. All {@code bound} possible 33851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code int} values are produced with (approximately) equal 33937db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * probability. The method {@code nextInt(int bound)} is implemented by 34051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * class {@code Random} as if by: 34151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 34237db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * public int nextInt(int bound) { 34337db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * if (bound <= 0) 34437db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * throw new IllegalArgumentException("bound must be positive"); 34551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 34637db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * if ((bound & -bound) == bound) // i.e., bound is a power of 2 34737db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * return (int)((bound * (long)next(31)) >> 31); 34851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 34951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * int bits, val; 35051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * do { 35151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * bits = next(31); 35237db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * val = bits % bound; 35337db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * } while (bits - val + (bound-1) < 0); 35451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return val; 35551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 35651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 35751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The hedge "approximately" is used in the foregoing description only 35851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * because the next method is only approximately an unbiased source of 35951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * independently chosen bits. If it were a perfect source of randomly 36051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * chosen bits, then the algorithm shown would choose {@code int} 36151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * values from the stated range with perfect uniformity. 36251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 36351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The algorithm is slightly tricky. It rejects values that would result 36451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * in an uneven distribution (due to the fact that 2^31 is not divisible 36551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * by n). The probability of a value being rejected depends on n. The 36651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * worst case is n=2^30+1, for which the probability of a reject is 1/2, 36751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * and the expected number of iterations before the loop terminates is 2. 36851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 36951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The algorithm treats the case where n is a power of two specially: it 37051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * returns the correct number of high-order bits from the underlying 37151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * pseudo-random number generator. In the absence of special treatment, 37251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * the correct number of <i>low-order</i> bits would be returned. Linear 37351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * congruential pseudo-random number generators such as the one 37451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * implemented by this class are known to have short periods in the 37551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * sequence of values of their low-order bits. Thus, this special case 37651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * greatly increases the length of the sequence of values returned by 37751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * successive calls to this method if n is a small power of two. 37851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 37937db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * @param bound the upper bound (exclusive). Must be positive. 38051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed {@code int} 38137db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * value between zero (inclusive) and {@code bound} (exclusive) 38251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * from this random number generator's sequence 38337db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * @throws IllegalArgumentException if bound is not positive 38451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @since 1.2 38551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 38637db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer public int nextInt(int bound) { 38737db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer if (bound <= 0) 38837db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer throw new IllegalArgumentException(BadBound); 38951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 39037db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer int r = next(31); 39137db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer int m = bound - 1; 39237db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer if ((bound & m) == 0) // i.e., bound is a power of 2 39337db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer r = (int)((bound * (long)r) >> 31); 39437db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer else { 39537db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer for (int u = r; 39637db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer u - (r = u % bound) + m < 0; 39737db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer u = next(31)) 39837db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer ; 39937db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer } 40037db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer return r; 40151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 40251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 40351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 40451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, uniformly distributed {@code long} 40551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value from this random number generator's sequence. The general 40651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * contract of {@code nextLong} is that one {@code long} value is 40751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * pseudorandomly generated and returned. 40851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 40951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextLong} is implemented by class {@code Random} 41051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 41151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 41251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public long nextLong() { 41351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return ((long)next(32) << 32) + next(32); 41451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 41551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 41651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Because class {@code Random} uses a seed with only 48 bits, 41751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * this algorithm will not return all possible {@code long} values. 41851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 41951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed {@code long} 42051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value from this random number generator's sequence 42151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 42251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public long nextLong() { 42351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // it's okay that the bottom word remains signed. 42451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return ((long)(next(32)) << 32) + next(32); 42551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 42651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 42751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 42851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, uniformly distributed 42951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code boolean} value from this random number generator's 43051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * sequence. The general contract of {@code nextBoolean} is that one 43151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code boolean} value is pseudorandomly generated and returned. The 43251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * values {@code true} and {@code false} are produced with 43351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * (approximately) equal probability. 43451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 43551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextBoolean} is implemented by class {@code Random} 43651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 43751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 43851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public boolean nextBoolean() { 43951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return next(1) != 0; 44051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 44151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 44251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed 44351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code boolean} value from this random number generator's 44451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * sequence 44551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @since 1.2 44651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 44751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public boolean nextBoolean() { 44851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return next(1) != 0; 44951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 45051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 45151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 45251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, uniformly distributed {@code float} 45351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value between {@code 0.0} and {@code 1.0} from this random 45451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * number generator's sequence. 45551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 45651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The general contract of {@code nextFloat} is that one 45751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code float} value, chosen (approximately) uniformly from the 45851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * range {@code 0.0f} (inclusive) to {@code 1.0f} (exclusive), is 45937db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * pseudorandomly generated and returned. All 2<sup>24</sup> possible 46037db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * {@code float} values of the form <i>m x </i>2<sup>-24</sup>, 46137db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer * where <i>m</i> is a positive integer less than 2<sup>24</sup>, are 46251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * produced with (approximately) equal probability. 46351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 46451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextFloat} is implemented by class {@code Random} 46551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 46651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 46751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public float nextFloat() { 46851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return next(24) / ((float)(1 << 24)); 46951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 47051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 47151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The hedge "approximately" is used in the foregoing description only 47251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * because the next method is only approximately an unbiased source of 47351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * independently chosen bits. If it were a perfect source of randomly 47451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * chosen bits, then the algorithm shown would choose {@code float} 47551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * values from the stated range with perfect uniformity.<p> 47651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * [In early versions of Java, the result was incorrectly calculated as: 47751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 47851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return next(30) / ((float)(1 << 30));}</pre> 47951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This might seem to be equivalent, if not better, but in fact it 48051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * introduced a slight nonuniformity because of the bias in the rounding 48151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * of floating-point numbers: it was slightly more likely that the 48251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * low-order bit of the significand would be 0 than that it would be 1.] 48351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 48451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed {@code float} 48551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value between {@code 0.0} and {@code 1.0} from this 48651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * random number generator's sequence 48751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 48851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public float nextFloat() { 48951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return next(24) / ((float)(1 << 24)); 49051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 49151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 49251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 49351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, uniformly distributed 49451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} value between {@code 0.0} and 49551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code 1.0} from this random number generator's sequence. 49651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 49751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The general contract of {@code nextDouble} is that one 49851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} value, chosen (approximately) uniformly from the 49951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * range {@code 0.0d} (inclusive) to {@code 1.0d} (exclusive), is 50051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * pseudorandomly generated and returned. 50151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 50251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextDouble} is implemented by class {@code Random} 50351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * as if by: 50451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 50551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public double nextDouble() { 50651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return (((long)next(26) << 27) + next(27)) 50751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * / (double)(1L << 53); 50851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 50951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 51051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The hedge "approximately" is used in the foregoing description only 51151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * because the {@code next} method is only approximately an unbiased 51251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * source of independently chosen bits. If it were a perfect source of 51351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * randomly chosen bits, then the algorithm shown would choose 51451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} values from the stated range with perfect uniformity. 51551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>[In early versions of Java, the result was incorrectly calculated as: 51651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 51751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return (((long)next(27) << 27) + next(27)) 51851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * / (double)(1L << 54);}</pre> 51951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This might seem to be equivalent, if not better, but in fact it 52051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * introduced a large nonuniformity because of the bias in the rounding 52151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * of floating-point numbers: it was three times as likely that the 52251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * low-order bit of the significand would be 0 than that it would be 1! 52351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This nonuniformity probably doesn't matter much in practice, but we 52451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * strive for perfection.] 52551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 52651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, uniformly distributed {@code double} 52751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * value between {@code 0.0} and {@code 1.0} from this 52851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * random number generator's sequence 52951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @see Math#random 53051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 53151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski public double nextDouble() { 53237db1d741fe624b67fb432aa453019c9a879a6f7Tobias Thierer return (((long)(next(26)) << 27) + next(27)) * DOUBLE_UNIT; 53351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 53451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 53551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private double nextNextGaussian; 53651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private boolean haveNextNextGaussian = false; 53751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 53851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 53951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Returns the next pseudorandom, Gaussian ("normally") distributed 54051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} value with mean {@code 0.0} and standard 54151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * deviation {@code 1.0} from this random number generator's sequence. 54251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p> 54351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * The general contract of {@code nextGaussian} is that one 54451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} value, chosen from (approximately) the usual 54551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * normal distribution with mean {@code 0.0} and standard deviation 54651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code 1.0}, is pseudorandomly generated and returned. 54751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 54851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <p>The method {@code nextGaussian} is implemented by class 54951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code Random} as if by a threadsafe version of the following: 55051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * <pre> {@code 55151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * private double nextNextGaussian; 55251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * private boolean haveNextNextGaussian = false; 55351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 55451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * public double nextGaussian() { 55551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * if (haveNextNextGaussian) { 55651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * haveNextNextGaussian = false; 55751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return nextNextGaussian; 55851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * } else { 55951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * double v1, v2, s; 56051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * do { 56151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0 56251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0 56351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * s = v1 * v1 + v2 * v2; 56451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * } while (s >= 1 || s == 0); 56551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s); 56651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * nextNextGaussian = v2 * multiplier; 56751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * haveNextNextGaussian = true; 56851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * return v1 * multiplier; 56951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * } 57051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * }}</pre> 57151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * This uses the <i>polar method</i> of G. E. P. Box, M. E. Muller, and 57251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * G. Marsaglia, as described by Donald E. Knuth in <i>The Art of 57351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Computer Programming</i>, Volume 3: <i>Seminumerical Algorithms</i>, 57451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * section 3.4.1, subsection C, algorithm P. Note that it generates two 57551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * independent values at the cost of only one call to {@code StrictMath.log} 57651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * and one call to {@code StrictMath.sqrt}. 57751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 57851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @return the next pseudorandom, Gaussian ("normally") distributed 57951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * {@code double} value with mean {@code 0.0} and 58051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * standard deviation {@code 1.0} from this random number 58151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * generator's sequence 58251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 58351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski synchronized public double nextGaussian() { 58451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // See Knuth, ACP, Section 3.4.1 Algorithm C. 58551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski if (haveNextNextGaussian) { 58651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski haveNextNextGaussian = false; 58751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return nextNextGaussian; 58851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } else { 58951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski double v1, v2, s; 59051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski do { 59151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski v1 = 2 * nextDouble() - 1; // between -1 and 1 59251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski v2 = 2 * nextDouble() - 1; // between -1 and 1 59351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski s = v1 * v1 + v2 * v2; 59451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } while (s >= 1 || s == 0); 59551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s); 59651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski nextNextGaussian = v2 * multiplier; 59751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski haveNextNextGaussian = true; 59851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski return v1 * multiplier; 59951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 60051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 60151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 6022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong // stream methods, coded in a way intended to better isolate for 6032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong // maintenance purposes the small differences across forms. 6042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 6052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 6062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number of 6072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * pseudorandom {@code int} values. 6082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code int} value is generated as if it's the result of 6102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * calling the method {@link #nextInt()}. 6112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 6132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code int} values 6142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 6152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero 6162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 6172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 6182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public IntStream ints(long streamSize) { 6192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 6202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 6212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.intStream 6222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomIntsSpliterator 6232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, Integer.MAX_VALUE, 0), 6242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 6252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 6262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 6272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 6282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code int} 6292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * values. 6302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code int} value is generated as if it's the result of 6322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * calling the method {@link #nextInt()}. 6332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 6352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * ints(Long.MAX_VALUE)}. 6362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code int} values 6382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 6392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 6402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public IntStream ints() { 6412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.intStream 6422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomIntsSpliterator 6432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, Integer.MAX_VALUE, 0), 6442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 6452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 6462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 6472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 6482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number 6492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of pseudorandom {@code int} values, each conforming to the given 6502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * origin (inclusive) and bound (exclusive). 6512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code int} value is generated as if it's the result of 6532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * calling the following method with the origin and bound: 6542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 6552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int nextInt(int origin, int bound) { 6562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int n = bound - origin; 6572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if (n > 0) { 6582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return nextInt(n) + origin; 6592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 6602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else { // range not representable as int 6612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int r; 6622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * do { 6632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = nextInt(); 6642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } while (r < origin || r >= bound); 6652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 6662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 6672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 6682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 6702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 6712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 6722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code int} values, 6732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 6742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 6752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero, or {@code randomNumberOrigin} 6762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 6772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 6782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 6792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public IntStream ints(long streamSize, int randomNumberOrigin, 6802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong int randomNumberBound) { 6812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 6822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 6832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (randomNumberOrigin >= randomNumberBound) 6842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 6852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.intStream 6862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomIntsSpliterator 6872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, randomNumberOrigin, randomNumberBound), 6882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 6892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 6902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 6912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 6922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code 6932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int} values, each conforming to the given origin (inclusive) and bound 6942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (exclusive). 6952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 6962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code int} value is generated as if it's the result of 6972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * calling the following method with the origin and bound: 6982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 6992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int nextInt(int origin, int bound) { 7002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int n = bound - origin; 7012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if (n > 0) { 7022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return nextInt(n) + origin; 7032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 7042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else { // range not representable as int 7052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * int r; 7062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * do { 7072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = nextInt(); 7082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } while (r < origin || r >= bound); 7092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 7102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 7112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 7122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 7142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}. 7152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 7172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 7182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code int} values, 7192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 7202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code randomNumberOrigin} 7212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 7222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 7232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 7242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public IntStream ints(int randomNumberOrigin, int randomNumberBound) { 7252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (randomNumberOrigin >= randomNumberBound) 7262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 7272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.intStream 7282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomIntsSpliterator 7292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound), 7302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 7312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 7322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 7332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 7342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number of 7352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * pseudorandom {@code long} values. 7362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code long} value is generated as if it's the result 7382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the method {@link #nextLong()}. 7392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 7412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code long} values 7422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 7432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero 7442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 7452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 7462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public LongStream longs(long streamSize) { 7472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 7482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 7492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.longStream 7502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomLongsSpliterator 7512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, Long.MAX_VALUE, 0L), 7522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 7532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 7542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 7552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 7562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code long} 7572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * values. 7582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code long} value is generated as if it's the result 7602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the method {@link #nextLong()}. 7612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 7632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * longs(Long.MAX_VALUE)}. 7642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code long} values 7662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 7672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 7682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public LongStream longs() { 7692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.longStream 7702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomLongsSpliterator 7712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, Long.MAX_VALUE, 0L), 7722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 7732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 7742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 7752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 7762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number of 7772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * pseudorandom {@code long}, each conforming to the given origin 7782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (inclusive) and bound (exclusive). 7792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 7802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code long} value is generated as if it's the result 7812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the following method with the origin and bound: 7822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 7832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long nextLong(long origin, long bound) { 7842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long r = nextLong(); 7852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long n = bound - origin, m = n - 1; 7862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if ((n & m) == 0L) // power of two 7872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = (r & m) + origin; 7882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else if (n > 0L) { // reject over-represented candidates 7892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * for (long u = r >>> 1; // ensure nonnegative 7902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * u + m - (r = u % n) < 0L; // rejection check 7912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * u = nextLong() >>> 1) // retry 7922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * ; 7932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r += origin; 7942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 7952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else { // range not representable as long 7962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * while (r < origin || r >= bound) 7972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = nextLong(); 7982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 7992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 8002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 8012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 8032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 8042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 8052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code long} values, 8062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 8072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 8082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero, or {@code randomNumberOrigin} 8092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 8102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 8112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 8122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public LongStream longs(long streamSize, long randomNumberOrigin, 8132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long randomNumberBound) { 8142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 8152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 8162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (randomNumberOrigin >= randomNumberBound) 8172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 8182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.longStream 8192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomLongsSpliterator 8202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, randomNumberOrigin, randomNumberBound), 8212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 8222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 8232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 8242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 8252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code 8262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long} values, each conforming to the given origin (inclusive) and bound 8272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (exclusive). 8282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code long} value is generated as if it's the result 8302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the following method with the origin and bound: 8312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 8322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long nextLong(long origin, long bound) { 8332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long r = nextLong(); 8342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * long n = bound - origin, m = n - 1; 8352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if ((n & m) == 0L) // power of two 8362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = (r & m) + origin; 8372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else if (n > 0L) { // reject over-represented candidates 8382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * for (long u = r >>> 1; // ensure nonnegative 8392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * u + m - (r = u % n) < 0L; // rejection check 8402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * u = nextLong() >>> 1) // retry 8412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * ; 8422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r += origin; 8432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 8442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * else { // range not representable as long 8452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * while (r < origin || r >= bound) 8462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = nextLong(); 8472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * } 8482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 8492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 8502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 8522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}. 8532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 8552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 8562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code long} values, 8572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 8582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code randomNumberOrigin} 8592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 8602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 8612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 8622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public LongStream longs(long randomNumberOrigin, long randomNumberBound) { 8632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (randomNumberOrigin >= randomNumberBound) 8642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 8652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.longStream 8662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomLongsSpliterator 8672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound), 8682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 8692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 8702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 8712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 8722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number of 8732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * pseudorandom {@code double} values, each between zero 8742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (inclusive) and one (exclusive). 8752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code double} value is generated as if it's the result 8772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the method {@link #nextDouble()}. 8782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 8802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of {@code double} values 8812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 8822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero 8832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 8842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 8852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public DoubleStream doubles(long streamSize) { 8862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 8872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 8882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.doubleStream 8892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomDoublesSpliterator 8902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, Double.MAX_VALUE, 0.0), 8912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 8922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 8932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 8942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 8952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code 8962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double} values, each between zero (inclusive) and one 8972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (exclusive). 8982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 8992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code double} value is generated as if it's the result 9002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the method {@link #nextDouble()}. 9012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 9032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * doubles(Long.MAX_VALUE)}. 9042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code double} values 9062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 9072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 9082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public DoubleStream doubles() { 9092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.doubleStream 9102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomDoublesSpliterator 9112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, Double.MAX_VALUE, 0.0), 9122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 9132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 9142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 9152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 9162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns a stream producing the given {@code streamSize} number of 9172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * pseudorandom {@code double} values, each conforming to the given origin 9182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (inclusive) and bound (exclusive). 9192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code double} value is generated as if it's the result 9212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the following method with the origin and bound: 9222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 9232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double nextDouble(double origin, double bound) { 9242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double r = nextDouble(); 9252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = r * (bound - origin) + origin; 9262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if (r >= bound) // correct for rounding 9272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = Math.nextDown(bound); 9282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 9292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 9302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param streamSize the number of values to generate 9322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 9332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 9342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code double} values, 9352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 9362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code streamSize} is 9372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * less than zero 9382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code randomNumberOrigin} 9392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 9402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 9412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 9422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public DoubleStream doubles(long streamSize, double randomNumberOrigin, 9432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong double randomNumberBound) { 9442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (streamSize < 0L) 9452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadSize); 9462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (!(randomNumberOrigin < randomNumberBound)) 9472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 9482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.doubleStream 9492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomDoublesSpliterator 9502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, streamSize, randomNumberOrigin, randomNumberBound), 9512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 9522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 9532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 9542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 9552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Returns an effectively unlimited stream of pseudorandom {@code 9562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double} values, each conforming to the given origin (inclusive) and bound 9572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * (exclusive). 9582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <p>A pseudorandom {@code double} value is generated as if it's the result 9602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * of calling the following method with the origin and bound: 9612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * <pre> {@code 9622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double nextDouble(double origin, double bound) { 9632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * double r = nextDouble(); 9642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = r * (bound - origin) + origin; 9652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * if (r >= bound) // correct for rounding 9662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * r = Math.nextDown(bound); 9672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * return r; 9682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * }}</pre> 9692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @implNote This method is implemented to be equivalent to {@code 9712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)}. 9722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * 9732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberOrigin the origin (inclusive) of each random value 9742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @param randomNumberBound the bound (exclusive) of each random value 9752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @return a stream of pseudorandom {@code double} values, 9762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * each with the given origin (inclusive) and bound (exclusive) 9772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @throws IllegalArgumentException if {@code randomNumberOrigin} 9782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * is greater than or equal to {@code randomNumberBound} 9792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * @since 1.8 9802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 9812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) { 9822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (!(randomNumberOrigin < randomNumberBound)) 9832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong throw new IllegalArgumentException(BadRange); 9842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return StreamSupport.doubleStream 9852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (new RandomDoublesSpliterator 9862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound), 9872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong false); 9882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 9892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 9902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 9912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Spliterator for int streams. We multiplex the four int 9922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * versions into one class by treating a bound less than origin as 9932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * unbounded, and also by treating "infinite" as equivalent to 9942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Long.MAX_VALUE. For splits, it uses the standard divide-by-two 9952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * approach. The long and double versions of this class are 9962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * identical except for types. 9972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 9982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final class RandomIntsSpliterator implements Spliterator.OfInt { 9992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final Random rng; 10002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long index; 10012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long fence; 10022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final int origin; 10032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final int bound; 10042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong RandomIntsSpliterator(Random rng, long index, long fence, 10052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong int origin, int bound) { 10062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.rng = rng; this.index = index; this.fence = fence; 10072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.origin = origin; this.bound = bound; 10082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public RandomIntsSpliterator trySplit() { 10112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, m = (i + fence) >>> 1; 10122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (m <= i) ? null : 10132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong new RandomIntsSpliterator(rng, i, index = m, origin, bound); 10142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public long estimateSize() { 10172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return fence - index; 10182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public int characteristics() { 10212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (Spliterator.SIZED | Spliterator.SUBSIZED | 10222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Spliterator.NONNULL | Spliterator.IMMUTABLE); 10232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public boolean tryAdvance(IntConsumer consumer) { 10262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 10272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 10282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 10292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(rng.internalNextInt(origin, bound)); 10302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = i + 1; 10312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return true; 10322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return false; 10342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public void forEachRemaining(IntConsumer consumer) { 10372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 10382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 10392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 10402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = f; 10412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Random r = rng; 10422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong int o = origin, b = bound; 10432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong do { 10442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(r.internalNextInt(o, b)); 10452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } while (++i < f); 10462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 10512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Spliterator for long streams. 10522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 10532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final class RandomLongsSpliterator implements Spliterator.OfLong { 10542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final Random rng; 10552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long index; 10562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long fence; 10572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long origin; 10582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long bound; 10592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong RandomLongsSpliterator(Random rng, long index, long fence, 10602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long origin, long bound) { 10612c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.rng = rng; this.index = index; this.fence = fence; 10622c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.origin = origin; this.bound = bound; 10632c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10642c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10652c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public RandomLongsSpliterator trySplit() { 10662c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, m = (i + fence) >>> 1; 10672c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (m <= i) ? null : 10682c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong new RandomLongsSpliterator(rng, i, index = m, origin, bound); 10692c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10702c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10712c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public long estimateSize() { 10722c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return fence - index; 10732c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10742c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10752c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public int characteristics() { 10762c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (Spliterator.SIZED | Spliterator.SUBSIZED | 10772c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Spliterator.NONNULL | Spliterator.IMMUTABLE); 10782c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10792c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10802c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public boolean tryAdvance(LongConsumer consumer) { 10812c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 10822c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 10832c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 10842c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(rng.internalNextLong(origin, bound)); 10852c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = i + 1; 10862c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return true; 10872c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10882c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return false; 10892c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 10902c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 10912c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public void forEachRemaining(LongConsumer consumer) { 10922c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 10932c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 10942c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 10952c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = f; 10962c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Random r = rng; 10972c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long o = origin, b = bound; 10982c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong do { 10992c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(r.internalNextLong(o, b)); 11002c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } while (++i < f); 11012c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11022c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11032c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11042c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11052c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11062c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong /** 11072c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong * Spliterator for double streams. 11082c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong */ 11092c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong static final class RandomDoublesSpliterator implements Spliterator.OfDouble { 11102c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final Random rng; 11112c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long index; 11122c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final long fence; 11132c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final double origin; 11142c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong final double bound; 11152c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong RandomDoublesSpliterator(Random rng, long index, long fence, 11162c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong double origin, double bound) { 11172c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.rng = rng; this.index = index; this.fence = fence; 11182c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong this.origin = origin; this.bound = bound; 11192c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11202c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11212c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public RandomDoublesSpliterator trySplit() { 11222c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, m = (i + fence) >>> 1; 11232c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (m <= i) ? null : 11242c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong new RandomDoublesSpliterator(rng, i, index = m, origin, bound); 11252c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11262c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11272c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public long estimateSize() { 11282c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return fence - index; 11292c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11302c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11312c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public int characteristics() { 11322c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return (Spliterator.SIZED | Spliterator.SUBSIZED | 11332c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Spliterator.NONNULL | Spliterator.IMMUTABLE); 11342c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11352c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11362c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public boolean tryAdvance(DoubleConsumer consumer) { 11372c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 11382c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 11392c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 11402c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(rng.internalNextDouble(origin, bound)); 11412c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = i + 1; 11422c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return true; 11432c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11442c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong return false; 11452c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11462c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 11472c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong public void forEachRemaining(DoubleConsumer consumer) { 11482c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (consumer == null) throw new NullPointerException(); 11492c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong long i = index, f = fence; 11502c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong if (i < f) { 11512c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong index = f; 11522c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong Random r = rng; 11532c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong double o = origin, b = bound; 11542c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong do { 11552c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong consumer.accept(r.internalNextDouble(o, b)); 11562c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } while (++i < f); 11572c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11582c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11592c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong } 11602c4230d24a2349039b4d7d513d0fb61542bc4cb7Yi Kong 116151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 116251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Serializable fields for Random. 116351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * 116451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @serialField seed long 116551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * seed for random computations 116651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @serialField nextNextGaussian double 116751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * next Gaussian to be returned 116851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * @serialField haveNextNextGaussian boolean 116951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * nextNextGaussian is valid 117051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 117151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final ObjectStreamField[] serialPersistentFields = { 117251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski new ObjectStreamField("seed", Long.TYPE), 117351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski new ObjectStreamField("nextNextGaussian", Double.TYPE), 117451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski new ObjectStreamField("haveNextNextGaussian", Boolean.TYPE) 117551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski }; 117651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 117751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 117851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Reconstitute the {@code Random} instance from a stream (that is, 117951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * deserialize it). 118051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 118151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private void readObject(java.io.ObjectInputStream s) 118251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski throws java.io.IOException, ClassNotFoundException { 118351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 118451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski ObjectInputStream.GetField fields = s.readFields(); 118551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 118651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // The seed is read in as {@code long} for 118751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // historical reasons, but it is converted to an AtomicLong. 118851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski long seedVal = fields.get("seed", -1L); 118951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski if (seedVal < 0) 119051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski throw new java.io.StreamCorruptedException( 119151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski "Random: invalid seed"); 119251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski resetSeed(seedVal); 119351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski nextNextGaussian = fields.get("nextNextGaussian", 0.0); 119451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski haveNextNextGaussian = fields.get("haveNextNextGaussian", false); 119551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 119651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 119751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski /** 119851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski * Save the {@code Random} instance to a stream. 119951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski */ 120051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski synchronized private void writeObject(ObjectOutputStream s) 120151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski throws IOException { 120251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 120351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // set the values of the Serializable fields 120451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski ObjectOutputStream.PutField fields = s.putFields(); 120551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 120651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // The seed is serialized as a long for historical reasons. 120751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski fields.put("seed", seed.get()); 120851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski fields.put("nextNextGaussian", nextNextGaussian); 120951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski fields.put("haveNextNextGaussian", haveNextNextGaussian); 121051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 121151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // save them 121251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski s.writeFields(); 121351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 121451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski 121551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski // Support for resetting seed while deserializing 121651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final Unsafe unsafe = Unsafe.getUnsafe(); 121751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private static final long seedOffset; 121851b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski static { 121951b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski try { 122051b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski seedOffset = unsafe.objectFieldOffset 122151b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski (Random.class.getDeclaredField("seed")); 122251b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } catch (Exception ex) { throw new Error(ex); } 122351b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 122451b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski private void resetSeed(long seedVal) { 122551b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski unsafe.putObjectVolatile(this, seedOffset, new AtomicLong(seedVal)); 122651b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski } 122751b1b6997fd3f980076b8081f7f1165ccc2a4008Piotr Jastrzebski} 1228