Package Summary Overview Summary

### method:nextInt(int) [CHANGED]
### nextInt public int nextInt (int bound) Returns a pseudorandomly chosenpseudorandom, uniformly distributed `int` value between zero0 (inclusive) and the specified boundvalue (exclusive), drawn from this random number generator's sequence. The general contract of `nextInt` is that one `int` value in the specified range is pseudorandomly generated and returned. All `bound` possible `int` values are produced with (approximately) equal probability. Specified by: `nextInt` in interface `RandomGenerator` Overrides: `nextInt` in class `Random` Parameters: `bound` - the upper bound (exclusive) for the returned value. Must be positive. Returns: a pseudorandomly chosenthe next pseudorandom, uniformly distributed `int` value between zero (inclusive) and `thebound` (exclusive) from this random number generator's sequence Throws: `IllegalArgumentException` - if bound is not positive
### nextInt public int nextInt (int bound) Returns a pseudorandomly chosen `int` value between zero (inclusive) and the specified bound (exclusive). Specified by: `nextInt` in interface `RandomGenerator` Overrides: `nextInt` in class `Random` Parameters: `bound` - the upper bound (exclusive) for the returned value. Must be positive. Returns: a pseudorandomly chosen `int` value between zero (inclusive) and the bound (exclusive) Throws: `IllegalArgumentException` - if `bound` is not positive | ### nextInt public int nextInt (int bound) Returns a pseudorandom, uniformly distributed `int` value between 0 (inclusive) and the specified value (exclusive), drawn from this random number generator's sequence. The general contract of `nextInt` is that one `int` value in the specified range is pseudorandomly generated and returned. All `bound` possible `int` values are produced with (approximately) equal probability. Specified by: `nextInt` in interface `RandomGenerator` Overrides: `nextInt` in class `Random` Parameters: `bound` - the upper bound (exclusive). Must be positive. Returns: the next pseudorandom, uniformly distributed `int` value between zero (inclusive) and `bound` (exclusive) from this random number generator's sequence Throws: `IllegalArgumentException` - if bound is not positive

### method:ints(long) [CHANGED]
### ints public IntStream ints (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `int` values. A pseudorandom `int` value is generated as if it's the result of calling the method `Random.nextInt()`. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandomly chosenpseudorandom `int` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8
### ints public IntStream ints (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `int` values. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandomly chosen `int` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8 | ### ints public IntStream ints (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandom `int` values. A pseudorandom `int` value is generated as if it's the result of calling the method `Random.nextInt()`. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandom `int` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8

### method:ints() [CHANGED]
### ints public IntStream ints() Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `int` values. A pseudorandom `int` value is generated as if it's the result of calling the method `Random.nextInt()`. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosenpseudorandom `int` values Since: 1.8
### ints public IntStream ints() Returns an effectively unlimited stream of pseudorandomly chosen `int` values. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosen `int` values Since: 1.8 | ### ints public IntStream ints() Returns an effectively unlimited stream of pseudorandom `int` values. A pseudorandom `int` value is generated as if it's the result of calling the method `Random.nextInt()`. Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE)`. Returns: a stream of pseudorandom `int` values Since: 1.8

### method:ints(long,int,int) [CHANGED]
### ints public IntStream ints (long streamSize, int randomNumberOrigin, int randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `int` values, whereeach value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `int` value is generated as if it's the result of calling the following method with the origin and bound:
     int nextInt(int origin, int bound) {
       int n = bound - origin;
       if (n > 0) {
         return nextInt(n) + origin;
       }
       else {  // range not representable as int
         int r;
         do {
           r = nextInt();
         } while (r < origin || r >= bound);
         return r;
       }
     }
Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `int` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### ints public IntStream ints (long streamSize, int randomNumberOrigin, int randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `int` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `int` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### ints public IntStream ints (long streamSize, int randomNumberOrigin, int randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandom `int` values, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `int` value is generated as if it's the result of calling the following method with the origin and bound:
     int nextInt(int origin, int bound) {
       int n = bound - origin;
       if (n > 0) {
         return nextInt(n) + origin;
       }
       else {  // range not representable as int
         int r;
         do {
           r = nextInt();
         } while (r < origin || r >= bound);
         return r;
       }
     }
Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `int` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8

### method:ints(int,int) [CHANGED]
### ints public IntStream ints (int randomNumberOrigin, int randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `int` values, whereeach value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `int` value is generated as if it's the result of calling the following method with the origin and bound:
     int nextInt(int origin, int bound) {
       int n = bound - origin;
       if (n > 0) {
         return nextInt(n) + origin;
       }
       else {  // range not representable as int
         int r;
         do {
           r = nextInt();
         } while (r < origin || r >= bound);
         return r;
       }
     }
Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `int` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### ints public IntStream ints (int randomNumberOrigin, int randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosen `int` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `int` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### ints public IntStream ints (int randomNumberOrigin, int randomNumberBound) Returns an effectively unlimited stream of pseudorandom `int` values, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `int` value is generated as if it's the result of calling the following method with the origin and bound:
     int nextInt(int origin, int bound) {
       int n = bound - origin;
       if (n > 0) {
         return nextInt(n) + origin;
       }
       else {  // range not representable as int
         int r;
         do {
           r = nextInt();
         } while (r < origin || r >= bound);
         return r;
       }
     }
Specified by: `ints` in interface `RandomGenerator` Overrides: `ints` in class `Random` Implementation Note: This method is implemented to be equivalent to `ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `int` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8

### method:longs(long) [CHANGED]
### longs public LongStream longs (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `long` values. A pseudorandom `long` value is generated as if it's the result of calling the method `Random.nextLong()`. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandomly chosenpseudorandom `long` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8
### longs public LongStream longs (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `long` values. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandomly chosen `long` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8 | ### longs public LongStream longs (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandom `long` values. A pseudorandom `long` value is generated as if it's the result of calling the method `Random.nextLong()`. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandom `long` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8

### method:longs() [CHANGED]
### longs public LongStream longs() Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `long` values. A pseudorandom `long` value is generated as if it's the result of calling the method `Random.nextLong()`. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosenpseudorandom `long` values Since: 1.8
### longs public LongStream longs() Returns an effectively unlimited stream of pseudorandomly chosen `long` values. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosen `long` values Since: 1.8 | ### longs public LongStream longs() Returns an effectively unlimited stream of pseudorandom `long` values. A pseudorandom `long` value is generated as if it's the result of calling the method `Random.nextLong()`. Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE)`. Returns: a stream of pseudorandom `long` values Since: 1.8

### method:longs(long,long,long) [CHANGED]
### longs public LongStream longs (long streamSize, long randomNumberOrigin, long randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `long` values, where, each value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `long` value is generated as if it's the result of calling the following method with the origin and bound:
     long nextLong(long origin, long bound) {
       long r = nextLong();
       long n = bound - origin, m = n - 1;
       if ((n & m) == 0L)  // power of two
         r = (r & m) + origin;
       else if (n > 0L) {  // reject over-represented candidates
         for (long u = r >>> 1;            // ensure nonnegative
              u + m - (r = u % n) < 0L;    // rejection check
              u = nextLong() >>> 1) // retry
             ;
         r += origin;
       }
       else {              // range not representable as long
         while (r < origin || r >= bound)
           r = nextLong();
       }
       return r;
     }
Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `long` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### longs public LongStream longs (long streamSize, long randomNumberOrigin, long randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `long` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `long` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### longs public LongStream longs (long streamSize, long randomNumberOrigin, long randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandom `long`, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `long` value is generated as if it's the result of calling the following method with the origin and bound:
     long nextLong(long origin, long bound) {
       long r = nextLong();
       long n = bound - origin, m = n - 1;
       if ((n & m) == 0L)  // power of two
         r = (r & m) + origin;
       else if (n > 0L) {  // reject over-represented candidates
         for (long u = r >>> 1;            // ensure nonnegative
              u + m - (r = u % n) < 0L;    // rejection check
              u = nextLong() >>> 1) // retry
             ;
         r += origin;
       }
       else {              // range not representable as long
         while (r < origin || r >= bound)
           r = nextLong();
       }
       return r;
     }
Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `long` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8

### method:longs(long,long) [CHANGED]
### longs public LongStream longs (long randomNumberOrigin, long randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `long` values, whereeach value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `long` value is generated as if it's the result of calling the following method with the origin and bound:
     long nextLong(long origin, long bound) {
       long r = nextLong();
       long n = bound - origin, m = n - 1;
       if ((n & m) == 0L)  // power of two
         r = (r & m) + origin;
       else if (n > 0L) {  // reject over-represented candidates
         for (long u = r >>> 1;            // ensure nonnegative
              u + m - (r = u % n) < 0L;    // rejection check
              u = nextLong() >>> 1) // retry
             ;
         r += origin;
       }
       else {              // range not representable as long
         while (r < origin || r >= bound)
           r = nextLong();
       }
       return r;
     }
Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `long` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### longs public LongStream longs (long randomNumberOrigin, long randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosen `long` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `long` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### longs public LongStream longs (long randomNumberOrigin, long randomNumberBound) Returns an effectively unlimited stream of pseudorandom `long` values, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `long` value is generated as if it's the result of calling the following method with the origin and bound:
     long nextLong(long origin, long bound) {
       long r = nextLong();
       long n = bound - origin, m = n - 1;
       if ((n & m) == 0L)  // power of two
         r = (r & m) + origin;
       else if (n > 0L) {  // reject over-represented candidates
         for (long u = r >>> 1;            // ensure nonnegative
              u + m - (r = u % n) < 0L;    // rejection check
              u = nextLong() >>> 1) // retry
             ;
         r += origin;
       }
       else {              // range not representable as long
         while (r < origin || r >= bound)
           r = nextLong();
       }
       return r;
     }
Specified by: `longs` in interface `RandomGenerator` Overrides: `longs` in class `Random` Implementation Note: This method is implemented to be equivalent to `longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `long` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8

### method:doubles(long) [CHANGED]
### doubles public DoubleStream doubles (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `double` values, each between zero (inclusive) and one (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the method `Random.nextDouble()`. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of `pseudorandomly chosendouble` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8
### doubles public DoubleStream doubles (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `double` values. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of pseudorandomly chosen `double` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8 | ### doubles public DoubleStream doubles (long streamSize) Returns a stream producing the given `streamSize` number of pseudorandom `double` values, each between zero (inclusive) and one (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the method `Random.nextDouble()`. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate Returns: a stream of `double` values Throws: `IllegalArgumentException` - if `streamSize` is less than zero Since: 1.8

### method:doubles() [CHANGED]
### doubles public DoubleStream doubles() Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `double` values, each between zero (inclusive) and one (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the method `Random.nextDouble()`. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosenpseudorandom `double` values Since: 1.8
### doubles public DoubleStream doubles() Returns an effectively unlimited stream of pseudorandomly chosen `double` values. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE)`. Returns: a stream of pseudorandomly chosen `double` values Since: 1.8 | ### doubles public DoubleStream doubles() Returns an effectively unlimited stream of pseudorandom `double` values, each between zero (inclusive) and one (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the method `Random.nextDouble()`. Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE)`. Returns: a stream of pseudorandom `double` values Since: 1.8

### method:doubles(long,double,double) [CHANGED]
### doubles public DoubleStream doubles (long streamSize, double randomNumberOrigin, double randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosenpseudorandom `double` values, whereeach value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the following method with the origin and bound:
     double nextDouble(double origin, double bound) {
       double r = nextDouble();
       r = r * (bound - origin) + origin;
       if (r >= bound) // correct for rounding
         r = Math.nextDown(bound);
       return r;
     }
Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `double` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### doubles public DoubleStream doubles (long streamSize, double randomNumberOrigin, double randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandomly chosen `double` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `double` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### doubles public DoubleStream doubles (long streamSize, double randomNumberOrigin, double randomNumberBound) Returns a stream producing the given `streamSize` number of pseudorandom `double` values, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the following method with the origin and bound:
     double nextDouble(double origin, double bound) {
       double r = nextDouble();
       r = r * (bound - origin) + origin;
       if (r >= bound) // correct for rounding
         r = Math.nextDown(bound);
       return r;
     }
Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Parameters: `streamSize` - the number of values to generate `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `double` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `streamSize` is less than zero, or `randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8

### method:doubles(double,double) [CHANGED]
### doubles public DoubleStream doubles (double randomNumberOrigin, double randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosenpseudorandom `double` values, whereeach value is betweenconforming to the specifiedgiven origin (inclusive) and the specifiedbound (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the following method with the origin and bound:
     double nextDouble(double origin, double bound) {
       double r = nextDouble();
       r = r * (bound - origin) + origin;
       if (r >= bound) // correct for rounding
         r = Math.nextDown(bound);
       return r;
     }
Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the leastorigin (inclusive) of each random value that can be produced `randomNumberBound` - the upperbound (exclusive) forof each random value produced Returns: a stream of pseudorandomly chosenpseudorandom `double` values, each betweenwith the specifiedgiven origin (inclusive) and the specifiedbound (exclusive) Throws: `IllegalArgumentException` - if ``randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, orrandomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8
### doubles public DoubleStream doubles (double randomNumberOrigin, double randomNumberBound) Returns an effectively unlimited stream of pseudorandomly chosen `double` values, where each value is between the specified origin (inclusive) and the specified bound (exclusive). Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the least value that can be produced `randomNumberBound` - the upper bound (exclusive) for each value produced Returns: a stream of pseudorandomly chosen `double` values, each between the specified origin (inclusive) and the specified bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is not finite, or `randomNumberBound` is not finite, or `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8 | ### doubles public DoubleStream doubles (double randomNumberOrigin, double randomNumberBound) Returns an effectively unlimited stream of pseudorandom `double` values, each conforming to the given origin (inclusive) and bound (exclusive). A pseudorandom `double` value is generated as if it's the result of calling the following method with the origin and bound:
     double nextDouble(double origin, double bound) {
       double r = nextDouble();
       r = r * (bound - origin) + origin;
       if (r >= bound) // correct for rounding
         r = Math.nextDown(bound);
       return r;
     }
Specified by: `doubles` in interface `RandomGenerator` Overrides: `doubles` in class `Random` Implementation Note: This method is implemented to be equivalent to `doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)` . Parameters: `randomNumberOrigin` - the origin (inclusive) of each random value `randomNumberBound` - the bound (exclusive) of each random value Returns: a stream of pseudorandom `double` values, each with the given origin (inclusive) and bound (exclusive) Throws: `IllegalArgumentException` - if `randomNumberOrigin` is greater than or equal to `randomNumberBound` Since: 1.8