* Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

package java.util.random;

import java.util.function.DoubleConsumer;

import java.util.stream.Stream;

 * {@link ArbitrarilyJumpableRNG} interface, to minimize the effort

 * {@link AbstractSplittableRNG}.)

 * this class provides {@link Spliterator}-based implementations that

 * {@link ArbitrarilyJumpableRNG} differs from {@link JumpableRNG},

 * <p>An implementation of the {@link AbstractArbitrarilyJumpableRNG} class

 * @since 14

public abstract class AbstractArbitrarilyJumpableRNG

    extends AbstractSpliteratorRNG implements ArbitrarilyJumpableRNG {

     * the interface ArbitrarilyJumpableRNG.  Most of these methods

     * are in turn inherited from AbstractRNG and the non-public class

     * AbstractSpliteratorRNG; this file implements four versions of the

     * AbstractSpliteratorRNG, then the main public methods, followed by some

    // Methods required by class AbstractSpliteratorRNG

        return new RandomIntsSpliterator(this, index, fence, origin, bound);

        return new RandomLongsSpliterator(this, index, fence, origin, bound);

        return new RandomDoublesSpliterator(this, index, fence, origin, bound);

    Spliterator<RandomNumberGenerator> makeJumpsSpliterator(long index, long fence, double distance) {

        return new RandomJumpsSpliterator(this, index, fence, distance);

    Spliterator<JumpableRNG> makeLeapsSpliterator(long index, long fence, double distance) {

        return new RandomLeapsSpliterator(this, index, fence, distance);

    Spliterator<ArbitrarilyJumpableRNG> makeArbitraryJumpsSpliterator(long index, long fence, double distance) {

        return new RandomArbitraryJumpsSpliterator(this, index, fence, distance);

    public abstract AbstractArbitrarilyJumpableRNG copy();

    private static <T> Stream<T> stream(Spliterator<T> srng) {

        return StreamSupport.stream(srng, false);

    }

     * Returns an effectively unlimited stream of new pseudorandom number generators, each of which

     * implements the {@link RandomNumberGenerator} interface, produced by jumping copies of this

     * generator by different integer multiples of the default jump distance.

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

     * @implNote This method is implemented to be equivalent to {@code

     *         jumps(Long.MAX_VALUE)}.

    public Stream<RandomNumberGenerator> jumps() {

        return stream(makeJumpsSpliterator(0L, Long.MAX_VALUE, defaultJumpDistance()));

     * {@link RandomNumberGenerator} interface, produced by jumping copies of this generator

     *

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

     *

     * @throws IllegalArgumentException if {@code streamSize} is less than zero

    public Stream<RandomNumberGenerator> jumps(long streamSize) {

        RNGSupport.checkStreamSize(streamSize);

        return stream(makeJumpsSpliterator(0L, streamSize, defaultJumpDistance()));

     * Returns an effectively unlimited stream of new pseudorandom number generators, each of which

     * implements the {@link RandomNumberGenerator} interface, produced by jumping copies of this

     * generator by different integer multiples of the specified jump distance.

     *

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

     *

     * @implNote This method is implemented to be equivalent to {@code

     *         jumps(Long.MAX_VALUE)}.

    public Stream<ArbitrarilyJumpableRNG> jumps(double distance) {

        return stream(makeArbitraryJumpsSpliterator(0L, Long.MAX_VALUE, distance));

     * Returns a stream producing the given {@code streamSize} number of new pseudorandom number

     * generators, each of which implements the {@link RandomNumberGenerator} interface, produced by

     * jumping copies of this generator by different integer multiples of the specified jump

     * distance.

     * @param distance   a distance to jump forward within the state cycle

     *

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

     *

     * @throws IllegalArgumentException if {@code streamSize} is less than zero

    public Stream<ArbitrarilyJumpableRNG> jumps(long streamSize, double distance) {

        RNGSupport.checkStreamSize(streamSize);

        return stream(makeArbitraryJumpsSpliterator(0L, streamSize, distance));

    public void leap() {

        jump(defaultLeapDistance());

    }

     * Returns an effectively unlimited stream of new pseudorandom number generators, each of which

     * implements the {@link RandomNumberGenerator} interface, produced by jumping copies of this

     * generator by different integer multiples of the default leap distance.

     * @implNote This method is implemented to be equivalent to {@code leaps(Long.MAX_VALUE)}.

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

    public Stream<JumpableRNG> leaps() {

        return stream(makeLeapsSpliterator(0L, Long.MAX_VALUE, defaultLeapDistance()));

     * Returns a stream producing the given {@code streamSize} number of new pseudorandom number

     * generators, each of which implements the {@link RandomNumberGenerator} interface, produced by

     * jumping copies of this generator by different integer multiples of the default leap

     * distance.

     *

     * @return a stream of objects that implement the {@link RandomNumberGenerator} interface

     *

     * @throws IllegalArgumentException if {@code streamSize} is less than zero

    public Stream<JumpableRNG> leaps(long streamSize) {

        return stream(makeLeapsSpliterator(0L, streamSize, defaultLeapDistance()));

     * Spliterator for int streams.  We multiplex the four int versions into one class by treating a

     * bound less than origin as unbounded, and also by treating "infinite" as equivalent to

     * {@code Long.MAX_VALUE}. For splits, we choose to override the method {@code trySplit()} to

     * try to optimize execution speed: instead of dividing a range in half, it breaks off the

     * largest possible chunk whose size is a power of two such that the remaining chunk is not

     * empty. In this way, the necessary jump distances will tend to be powers of two.  The long

     * and double versions of this class are identical except for types.

    static class RandomIntsSpliterator extends RNGSupport.RandomSpliterator implements Spliterator.OfInt {

        final ArbitrarilyJumpableRNG generatingRNG;

        RandomIntsSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, int origin, int bound) {

            super(index, fence);

            this.origin = origin; this.bound = bound;

            this.generatingRNG = generatingRNG;

            if (m <= i) return null;

            index = m;

            ArbitrarilyJumpableRNG r = generatingRNG;

            return new RandomIntsSpliterator(r.copyAndJump((double)delta), i, m, origin, bound);

                consumer.accept(RNGSupport.boundedNextInt(generatingRNG, origin, bound));

                ArbitrarilyJumpableRNG r = generatingRNG;

                    consumer.accept(RNGSupport.boundedNextInt(r, o, b));

     * Spliterator for long streams.

    static class RandomLongsSpliterator extends RNGSupport.RandomSpliterator implements Spliterator.OfLong {

        final ArbitrarilyJumpableRNG generatingRNG;

        RandomLongsSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, long origin, long bound) {

            super(index, fence);

            this.generatingRNG = generatingRNG;

            this.origin = origin; this.bound = bound;

            if (m <= i) return null;

            index = m;

            ArbitrarilyJumpableRNG r = generatingRNG;

            return new RandomLongsSpliterator(r.copyAndJump((double)delta), i, m, origin, bound);

                consumer.accept(RNGSupport.boundedNextLong(generatingRNG, origin, bound));

                ArbitrarilyJumpableRNG r = generatingRNG;

                    consumer.accept(RNGSupport.boundedNextLong(r, o, b));

     * Spliterator for double streams.

    static class RandomDoublesSpliterator extends RNGSupport.RandomSpliterator implements Spliterator.OfDouble {

        final ArbitrarilyJumpableRNG generatingRNG;

        RandomDoublesSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, double origin, double bound) {

            super(index, fence);

            this.generatingRNG = generatingRNG;

            this.origin = origin; this.bound = bound;

            if (m <= i) return null;

            index = m;

            ArbitrarilyJumpableRNG r = generatingRNG;

            return new RandomDoublesSpliterator(r.copyAndJump((double)delta), i, m, origin, bound);

                consumer.accept(RNGSupport.boundedNextDouble(generatingRNG, origin, bound));

                ArbitrarilyJumpableRNG r = generatingRNG;

                    consumer.accept(RNGSupport.boundedNextDouble(r, o, b));

     * Spliterator for stream of generators of type RandomNumberGenerator produced by jumps.

    static class RandomJumpsSpliterator extends RNGSupport.RandomSpliterator implements Spliterator<RandomNumberGenerator> {

        ArbitrarilyJumpableRNG generatingRNG;

        final double distance;

        RandomJumpsSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, double distance) {

            this.generatingRNG = generatingRNG; this.distance = distance;

        public Spliterator<RandomNumberGenerator> trySplit() {

            long i = index, delta = Long.highestOneBit((fence - i) - 1), m = i + delta;

            if (m <= i) return null;

            index = m;

            ArbitrarilyJumpableRNG r = generatingRNG;

            // Because delta is a power of two, (distance * (double)delta) can always be computed exactly.

            return new RandomJumpsSpliterator(r.copyAndJump(distance * (double)delta), i, m, distance);

        public boolean tryAdvance(Consumer<? super RandomNumberGenerator> consumer) {

                consumer.accept(generatingRNG.copyAndJump(distance));

        public void forEachRemaining(Consumer<? super RandomNumberGenerator> consumer) {

                ArbitrarilyJumpableRNG r = generatingRNG;

     * Spliterator for stream of generators of type RandomNumberGenerator produced by leaps.

    static class RandomLeapsSpliterator extends RNGSupport.RandomSpliterator implements Spliterator<JumpableRNG> {

        ArbitrarilyJumpableRNG generatingRNG;

        final double distance;

        RandomLeapsSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, double distance) {

            this.generatingRNG = generatingRNG; this.distance = distance;

        public Spliterator<JumpableRNG> trySplit() {

            long i = index, delta = Long.highestOneBit((fence - i) - 1), m = i + delta;

            if (m <= i) return null;

            index = m;

            // Because delta is a power of two, (distance * (double)delta) can always be computed exactly.

            return new RandomLeapsSpliterator(generatingRNG.copyAndJump(distance * (double)delta), i, m, distance);

        public boolean tryAdvance(Consumer<? super JumpableRNG> consumer) {

                consumer.accept(generatingRNG.copyAndJump(distance));

        public void forEachRemaining(Consumer<? super JumpableRNG> consumer) {

                ArbitrarilyJumpableRNG r = generatingRNG;

                do {

                    consumer.accept(r.copyAndJump(distance));

                } while (++i < f);

            }

        }

    }

    /**

     * Spliterator for stream of generators of type RandomNumberGenerator produced by arbitrary jumps.

     */

    static class RandomArbitraryJumpsSpliterator extends RNGSupport.RandomSpliterator implements Spliterator<ArbitrarilyJumpableRNG> {

        ArbitrarilyJumpableRNG generatingRNG;

        final double distance;

        RandomArbitraryJumpsSpliterator(ArbitrarilyJumpableRNG generatingRNG, long index, long fence, double distance) {

            super(index, fence);

            this.generatingRNG = generatingRNG; this.distance = distance;

        }

        public Spliterator<ArbitrarilyJumpableRNG> trySplit() {

            long i = index, delta = Long.highestOneBit((fence - i) - 1), m = i + delta;