ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/SplittableRandom.java
(Generate patch)

Comparing jsr166/src/main/java/util/SplittableRandom.java (file contents):
Revision 1.25 by dl, Tue Dec 2 12:17:38 2014 UTC vs.
Revision 1.33 by dl, Sat Nov 12 00:12:05 2016 UTC

# Line 26 | Line 26
26   package java.util;
27  
28   import java.util.concurrent.atomic.AtomicLong;
29 + import java.util.function.DoubleConsumer;
30   import java.util.function.IntConsumer;
31   import java.util.function.LongConsumer;
32 < import java.util.function.DoubleConsumer;
32 < import java.util.stream.StreamSupport;
32 > import java.util.stream.DoubleStream;
33   import java.util.stream.IntStream;
34   import java.util.stream.LongStream;
35 < import java.util.stream.DoubleStream;
35 > import java.util.stream.StreamSupport;
36  
37   /**
38   * A generator of uniform pseudorandom values applicable for use in
# Line 52 | Line 52 | import java.util.stream.DoubleStream;
52   * types and ranges, but similar properties are expected to hold, at
53   * least approximately, for others as well. The <em>period</em>
54   * (length of any series of generated values before it repeats) is at
55 < * least 2<sup>64</sup>. </li>
55 > * least 2<sup>64</sup>.
56   *
57 < * <li> Method {@link #split} constructs and returns a new
57 > * <li>Method {@link #split} constructs and returns a new
58   * SplittableRandom instance that shares no mutable state with the
59   * current instance. However, with very high probability, the
60   * values collectively generated by the two objects have the same
61   * statistical properties as if the same quantity of values were
62   * generated by a single thread using a single {@code
63 < * SplittableRandom} object.  </li>
63 > * SplittableRandom} object.
64   *
65   * <li>Instances of SplittableRandom are <em>not</em> thread-safe.
66   * They are designed to be split, not shared, across threads. For
# Line 71 | Line 71 | import java.util.stream.DoubleStream;
71   *
72   * <li>This class provides additional methods for generating random
73   * streams, that employ the above techniques when used in {@code
74 < * stream.parallel()} mode.</li>
74 > * stream.parallel()} mode.
75   *
76   * </ul>
77   *
# Line 219 | Line 219 | public final class SplittableRandom {
219          return seed += gamma;
220      }
221  
222 +    // IllegalArgumentException messages
223 +    static final String BAD_BOUND = "bound must be positive";
224 +    static final String BAD_RANGE = "bound must be greater than origin";
225 +    static final String BAD_SIZE  = "size must be non-negative";
226 +
227      /**
228       * The seed generator for default constructors.
229       */
230 <    private static final AtomicLong defaultGen = new AtomicLong(initialSeed());
231 <
232 <    private static long initialSeed() {
233 <        String pp = java.security.AccessController.doPrivileged(
234 <                new sun.security.action.GetPropertyAction(
235 <                        "java.util.secureRandomSeed"));
236 <        if (pp != null && pp.equalsIgnoreCase("true")) {
230 >    private static final AtomicLong defaultGen
231 >        = new AtomicLong(mix64(System.currentTimeMillis()) ^
232 >                         mix64(System.nanoTime()));
233 >
234 >    // at end of <clinit> to survive static initialization circularity
235 >    static {
236 >        if (java.security.AccessController.doPrivileged(
237 >            new java.security.PrivilegedAction<Boolean>() {
238 >                public Boolean run() {
239 >                    return Boolean.getBoolean("java.util.secureRandomSeed");
240 >                }})) {
241              byte[] seedBytes = java.security.SecureRandom.getSeed(8);
242 <            long s = (long)(seedBytes[0]) & 0xffL;
242 >            long s = (long)seedBytes[0] & 0xffL;
243              for (int i = 1; i < 8; ++i)
244 <                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
245 <            return s;
244 >                s = (s << 8) | ((long)seedBytes[i] & 0xffL);
245 >            defaultGen.set(s);
246          }
238 –        return (mix64(System.currentTimeMillis()) ^
239 –                mix64(System.nanoTime()));
247      }
248  
242 –    // IllegalArgumentException messages
243 –    static final String BadBound = "bound must be positive";
244 –    static final String BadRange = "bound must be greater than origin";
245 –    static final String BadSize  = "size must be non-negative";
246 –
249      /*
250       * Internal versions of nextX methods used by streams, as well as
251       * the public nextX(origin, bound) methods.  These exist mainly to
# Line 416 | Line 418 | public final class SplittableRandom {
418       */
419      public int nextInt(int bound) {
420          if (bound <= 0)
421 <            throw new IllegalArgumentException(BadBound);
421 >            throw new IllegalArgumentException(BAD_BOUND);
422          // Specialize internalNextInt for origin 0
423          int r = mix32(nextSeed());
424          int m = bound - 1;
# Line 444 | Line 446 | public final class SplittableRandom {
446       */
447      public int nextInt(int origin, int bound) {
448          if (origin >= bound)
449 <            throw new IllegalArgumentException(BadRange);
449 >            throw new IllegalArgumentException(BAD_RANGE);
450          return internalNextInt(origin, bound);
451      }
452  
# Line 468 | Line 470 | public final class SplittableRandom {
470       */
471      public long nextLong(long bound) {
472          if (bound <= 0)
473 <            throw new IllegalArgumentException(BadBound);
473 >            throw new IllegalArgumentException(BAD_BOUND);
474          // Specialize internalNextLong for origin 0
475          long r = mix64(nextSeed());
476          long m = bound - 1;
# Line 496 | Line 498 | public final class SplittableRandom {
498       */
499      public long nextLong(long origin, long bound) {
500          if (origin >= bound)
501 <            throw new IllegalArgumentException(BadRange);
501 >            throw new IllegalArgumentException(BAD_RANGE);
502          return internalNextLong(origin, bound);
503      }
504  
# Line 522 | Line 524 | public final class SplittableRandom {
524       */
525      public double nextDouble(double bound) {
526          if (!(bound > 0.0))
527 <            throw new IllegalArgumentException(BadBound);
527 >            throw new IllegalArgumentException(BAD_BOUND);
528          double result = (mix64(nextSeed()) >>> 11) * DOUBLE_UNIT * bound;
529          return (result < bound) ?  result : // correct for rounding
530              Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
531      }
532  
533 +        /**
534 +     * Generates a pseudorandom number with the indicated number of
535 +     * bits. Unlike in superclass @{link Random}, this method is never
536 +     * internally called or used by any other publicly accessible
537 +     * method.
538 +     *
539 +     * @param  bits random bits
540 +     * @return the next pseudorandom value from this random number
541 +     *         generator's sequence
542 +     */
543 +    protected int next(int bits) {
544 +        return (int)(nextLong() >>> (64 - bits));
545 +    }
546 +
547      /**
548       * Returns a pseudorandom {@code double} value between the specified
549       * origin (inclusive) and bound (exclusive).
# Line 541 | Line 557 | public final class SplittableRandom {
557       */
558      public double nextDouble(double origin, double bound) {
559          if (!(origin < bound))
560 <            throw new IllegalArgumentException(BadRange);
560 >            throw new IllegalArgumentException(BAD_RANGE);
561          return internalNextDouble(origin, bound);
562      }
563  
# Line 569 | Line 585 | public final class SplittableRandom {
585       */
586      public IntStream ints(long streamSize) {
587          if (streamSize < 0L)
588 <            throw new IllegalArgumentException(BadSize);
588 >            throw new IllegalArgumentException(BAD_SIZE);
589          return StreamSupport.intStream
590              (new RandomIntsSpliterator
591               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 610 | Line 626 | public final class SplittableRandom {
626      public IntStream ints(long streamSize, int randomNumberOrigin,
627                            int randomNumberBound) {
628          if (streamSize < 0L)
629 <            throw new IllegalArgumentException(BadSize);
629 >            throw new IllegalArgumentException(BAD_SIZE);
630          if (randomNumberOrigin >= randomNumberBound)
631 <            throw new IllegalArgumentException(BadRange);
631 >            throw new IllegalArgumentException(BAD_RANGE);
632          return StreamSupport.intStream
633              (new RandomIntsSpliterator
634               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 636 | Line 652 | public final class SplittableRandom {
652       */
653      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
654          if (randomNumberOrigin >= randomNumberBound)
655 <            throw new IllegalArgumentException(BadRange);
655 >            throw new IllegalArgumentException(BAD_RANGE);
656          return StreamSupport.intStream
657              (new RandomIntsSpliterator
658               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 655 | Line 671 | public final class SplittableRandom {
671       */
672      public LongStream longs(long streamSize) {
673          if (streamSize < 0L)
674 <            throw new IllegalArgumentException(BadSize);
674 >            throw new IllegalArgumentException(BAD_SIZE);
675          return StreamSupport.longStream
676              (new RandomLongsSpliterator
677               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 696 | Line 712 | public final class SplittableRandom {
712      public LongStream longs(long streamSize, long randomNumberOrigin,
713                              long randomNumberBound) {
714          if (streamSize < 0L)
715 <            throw new IllegalArgumentException(BadSize);
715 >            throw new IllegalArgumentException(BAD_SIZE);
716          if (randomNumberOrigin >= randomNumberBound)
717 <            throw new IllegalArgumentException(BadRange);
717 >            throw new IllegalArgumentException(BAD_RANGE);
718          return StreamSupport.longStream
719              (new RandomLongsSpliterator
720               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 722 | Line 738 | public final class SplittableRandom {
738       */
739      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
740          if (randomNumberOrigin >= randomNumberBound)
741 <            throw new IllegalArgumentException(BadRange);
741 >            throw new IllegalArgumentException(BAD_RANGE);
742          return StreamSupport.longStream
743              (new RandomLongsSpliterator
744               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 741 | Line 757 | public final class SplittableRandom {
757       */
758      public DoubleStream doubles(long streamSize) {
759          if (streamSize < 0L)
760 <            throw new IllegalArgumentException(BadSize);
760 >            throw new IllegalArgumentException(BAD_SIZE);
761          return StreamSupport.doubleStream
762              (new RandomDoublesSpliterator
763               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 784 | Line 800 | public final class SplittableRandom {
800      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
801                                  double randomNumberBound) {
802          if (streamSize < 0L)
803 <            throw new IllegalArgumentException(BadSize);
803 >            throw new IllegalArgumentException(BAD_SIZE);
804          if (!(randomNumberOrigin < randomNumberBound))
805 <            throw new IllegalArgumentException(BadRange);
805 >            throw new IllegalArgumentException(BAD_RANGE);
806          return StreamSupport.doubleStream
807              (new RandomDoublesSpliterator
808               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 810 | Line 826 | public final class SplittableRandom {
826       */
827      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
828          if (!(randomNumberOrigin < randomNumberBound))
829 <            throw new IllegalArgumentException(BadRange);
829 >            throw new IllegalArgumentException(BAD_RANGE);
830          return StreamSupport.doubleStream
831              (new RandomDoublesSpliterator
832               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 825 | Line 841 | public final class SplittableRandom {
841       * approach. The long and double versions of this class are
842       * identical except for types.
843       */
844 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
844 >    private static final class RandomIntsSpliterator
845 >            implements Spliterator.OfInt {
846          final SplittableRandom rng;
847          long index;
848          final long fence;
# Line 880 | Line 897 | public final class SplittableRandom {
897      /**
898       * Spliterator for long streams.
899       */
900 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
900 >    private static final class RandomLongsSpliterator
901 >            implements Spliterator.OfLong {
902          final SplittableRandom rng;
903          long index;
904          final long fence;
# Line 936 | Line 954 | public final class SplittableRandom {
954      /**
955       * Spliterator for double streams.
956       */
957 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
957 >    private static final class RandomDoublesSpliterator
958 >            implements Spliterator.OfDouble {
959          final SplittableRandom rng;
960          long index;
961          final long fence;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines