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.26 by jsr166, Wed Dec 31 07:54:13 2014 UTC vs.
Revision 1.36 by jsr166, Sun Nov 13 03:36:50 2016 UTC

# Line 52 | Line 52 | import java.util.stream.StreamSupport;
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.StreamSupport;
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 +     * low-order bits.  Because this class has no subclasses, this
536 +     * method cannot be invoked or overridden.
537 +     *
538 +     * @param  bits random bits
539 +     * @return the next pseudorandom value from this random number
540 +     *         generator's sequence
541 +     */
542 +    protected int next(int bits) {
543 +        return nextInt() >>> (32 - bits);
544 +    }
545 +
546 +    /**
547       * Returns a pseudorandom {@code double} value between the specified
548       * origin (inclusive) and bound (exclusive).
549       *
# Line 541 | Line 556 | public final class SplittableRandom {
556       */
557      public double nextDouble(double origin, double bound) {
558          if (!(origin < bound))
559 <            throw new IllegalArgumentException(BadRange);
559 >            throw new IllegalArgumentException(BAD_RANGE);
560          return internalNextDouble(origin, bound);
561      }
562  
# Line 569 | Line 584 | public final class SplittableRandom {
584       */
585      public IntStream ints(long streamSize) {
586          if (streamSize < 0L)
587 <            throw new IllegalArgumentException(BadSize);
587 >            throw new IllegalArgumentException(BAD_SIZE);
588          return StreamSupport.intStream
589              (new RandomIntsSpliterator
590               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 610 | Line 625 | public final class SplittableRandom {
625      public IntStream ints(long streamSize, int randomNumberOrigin,
626                            int randomNumberBound) {
627          if (streamSize < 0L)
628 <            throw new IllegalArgumentException(BadSize);
628 >            throw new IllegalArgumentException(BAD_SIZE);
629          if (randomNumberOrigin >= randomNumberBound)
630 <            throw new IllegalArgumentException(BadRange);
630 >            throw new IllegalArgumentException(BAD_RANGE);
631          return StreamSupport.intStream
632              (new RandomIntsSpliterator
633               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 636 | Line 651 | public final class SplittableRandom {
651       */
652      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
653          if (randomNumberOrigin >= randomNumberBound)
654 <            throw new IllegalArgumentException(BadRange);
654 >            throw new IllegalArgumentException(BAD_RANGE);
655          return StreamSupport.intStream
656              (new RandomIntsSpliterator
657               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 655 | Line 670 | public final class SplittableRandom {
670       */
671      public LongStream longs(long streamSize) {
672          if (streamSize < 0L)
673 <            throw new IllegalArgumentException(BadSize);
673 >            throw new IllegalArgumentException(BAD_SIZE);
674          return StreamSupport.longStream
675              (new RandomLongsSpliterator
676               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 696 | Line 711 | public final class SplittableRandom {
711      public LongStream longs(long streamSize, long randomNumberOrigin,
712                              long randomNumberBound) {
713          if (streamSize < 0L)
714 <            throw new IllegalArgumentException(BadSize);
714 >            throw new IllegalArgumentException(BAD_SIZE);
715          if (randomNumberOrigin >= randomNumberBound)
716 <            throw new IllegalArgumentException(BadRange);
716 >            throw new IllegalArgumentException(BAD_RANGE);
717          return StreamSupport.longStream
718              (new RandomLongsSpliterator
719               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 722 | Line 737 | public final class SplittableRandom {
737       */
738      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
739          if (randomNumberOrigin >= randomNumberBound)
740 <            throw new IllegalArgumentException(BadRange);
740 >            throw new IllegalArgumentException(BAD_RANGE);
741          return StreamSupport.longStream
742              (new RandomLongsSpliterator
743               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 741 | Line 756 | public final class SplittableRandom {
756       */
757      public DoubleStream doubles(long streamSize) {
758          if (streamSize < 0L)
759 <            throw new IllegalArgumentException(BadSize);
759 >            throw new IllegalArgumentException(BAD_SIZE);
760          return StreamSupport.doubleStream
761              (new RandomDoublesSpliterator
762               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 784 | Line 799 | public final class SplittableRandom {
799      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
800                                  double randomNumberBound) {
801          if (streamSize < 0L)
802 <            throw new IllegalArgumentException(BadSize);
802 >            throw new IllegalArgumentException(BAD_SIZE);
803          if (!(randomNumberOrigin < randomNumberBound))
804 <            throw new IllegalArgumentException(BadRange);
804 >            throw new IllegalArgumentException(BAD_RANGE);
805          return StreamSupport.doubleStream
806              (new RandomDoublesSpliterator
807               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 810 | Line 825 | public final class SplittableRandom {
825       */
826      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
827          if (!(randomNumberOrigin < randomNumberBound))
828 <            throw new IllegalArgumentException(BadRange);
828 >            throw new IllegalArgumentException(BAD_RANGE);
829          return StreamSupport.doubleStream
830              (new RandomDoublesSpliterator
831               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 825 | Line 840 | public final class SplittableRandom {
840       * approach. The long and double versions of this class are
841       * identical except for types.
842       */
843 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
843 >    private static final class RandomIntsSpliterator
844 >            implements Spliterator.OfInt {
845          final SplittableRandom rng;
846          long index;
847          final long fence;
# Line 880 | Line 896 | public final class SplittableRandom {
896      /**
897       * Spliterator for long streams.
898       */
899 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
899 >    private static final class RandomLongsSpliterator
900 >            implements Spliterator.OfLong {
901          final SplittableRandom rng;
902          long index;
903          final long fence;
# Line 936 | Line 953 | public final class SplittableRandom {
953      /**
954       * Spliterator for double streams.
955       */
956 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
956 >    private static final class RandomDoublesSpliterator
957 >            implements Spliterator.OfDouble {
958          final SplittableRandom rng;
959          long index;
960          final long fence;

Diff Legend

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