Java 类java.util.function.DoubleConsumer 实例源码

@Override
public final Array<T> forEachDouble(DoubleConsumer consumer) {
    final int length = length();
    if (isParallel() && length > 0) {
        final int processors = Runtime.getRuntime().availableProcessors();
        final int splitThreshold = parallel ? Math.max(length() / processors, 10000) : Integer.MAX_VALUE;
        final ForEach action = new ForEach(0, length - 1, splitThreshold, consumer);
        ForkJoinPool.commonPool().invoke(action);
    } else {
        for (int i=0; i<length; ++i) {
            final double value = getDouble(i);
            consumer.accept(value);
        }
    }
    return this;
}

public void autoMatchAll(DoubleConsumer progressReceiver) {
    if (autoMatchClasses(ClassifierLevel.Initial, absClassAutoMatchThreshold, relClassAutoMatchThreshold, progressReceiver)) {
        autoMatchClasses(ClassifierLevel.Initial, absClassAutoMatchThreshold, relClassAutoMatchThreshold, progressReceiver);
    }

    autoMatchLevel(ClassifierLevel.Intermediate, progressReceiver);
    autoMatchLevel(ClassifierLevel.Full, progressReceiver);
    autoMatchLevel(ClassifierLevel.Extra, progressReceiver);

    boolean matchedAny;

    do {
        matchedAny = autoMatchMethodArgs(ClassifierLevel.Full, absMethodArgAutoMatchThreshold, relMethodArgAutoMatchThreshold, progressReceiver);
    } while (matchedAny);

    env.getCache().clear();
}

@Override
public final DoubleStream peek(DoubleConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                   0) {
        @Override
        Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedDouble<Double>(sink) {
                @Override
                public void accept(double t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}

private <T, C> void runInParallel(List<T> workSet, Consumer<T> worker, DoubleConsumer progressReceiver) {
    if (workSet.isEmpty()) return;

    AtomicInteger itemsDone = new AtomicInteger();
    int updateRate = Math.max(1, workSet.size() / 200);

    workSet.parallelStream().forEach(workItem -> {
        worker.accept(workItem);

        int cItemsDone = itemsDone.incrementAndGet();

        if ((cItemsDone % updateRate) == 0) {
            progressReceiver.accept((double) cItemsDone / workSet.size());
        }
    });
}

/**
 * Returns an infinite sequential ordered {@code DoubleStream} produced by iterative
 * application of a function {@code f} to an initial element {@code seed},
 * producing a {@code Stream} consisting of {@code seed}, {@code f(seed)},
 * {@code f(f(seed))}, etc.
 *
 * <p>The first element (position {@code 0}) in the {@code DoubleStream}
 * will be the provided {@code seed}.  For {@code n > 0}, the element at
 * position {@code n}, will be the result of applying the function {@code f}
 *  to the element at position {@code n - 1}.
 *
 * <p>The action of applying {@code f} for one element
 * <a href="../concurrent/package-summary.html#MemoryVisibility"><i>happens-before</i></a>
 * the action of applying {@code f} for subsequent elements.  For any given
 * element the action may be performed in whatever thread the library
 * chooses.
 *
 * @param seed the initial element
 * @param f a function to be applied to the previous element to produce
 *          a new element
 * @return a new sequential {@code DoubleStream}
 */
public static DoubleStream iterate(final double seed, final DoubleUnaryOperator f) {
    Objects.requireNonNull(f);
    Spliterator.OfDouble spliterator = new Spliterators.AbstractDoubleSpliterator(Long.MAX_VALUE,
           Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL) {
        double prev;
        boolean started;

        @Override
        public boolean tryAdvance(DoubleConsumer action) {
            Objects.requireNonNull(action);
            double t;
            if (started)
                t = f.applyAsDouble(prev);
            else {
                t = seed;
                started = true;
            }
            action.accept(prev = t);
            return true;
        }
    };
    return StreamSupport.doubleStream(spliterator, false);
}

@Test(timeOut = 20_000, groups = "non-deterministic") public void testNextGaussianStatistically()
    throws SeedException {
  final BaseRandom rng = createRng();
  final int iterations = 10000;
  final SynchronizedDescriptiveStatistics stats = new SynchronizedDescriptiveStatistics();
  rng.gaussians(iterations).spliterator().forEachRemaining((DoubleConsumer) stats::addValue);

  final double observedSD = stats.getStandardDeviation();
  Reporter.log("Expected SD for Gaussians: 1, observed SD: " + observedSD);
  assertGreaterOrEqual(observedSD, 0.97);
  assertLessOrEqual(observedSD, 1.03);
  assertGreaterOrEqual(stats.getMax(), 2.0);
  assertLessOrEqual(stats.getMin(), -2.0);
  assertGreaterOrEqual(stats.getMean(), -0.1);
  assertLessOrEqual(stats.getMean(), 0.1);
  final double median = stats.getPercentile(50);
  assertGreaterOrEqual(median, -0.1);
  assertLessOrEqual(median, 0.1);
}

@Override
public final DoubleStream peek(DoubleConsumer action) {
    Objects.requireNonNull(action);
    return new StatelessOp<Double>(this, StreamShape.DOUBLE_VALUE,
                                   0) {
        @Override
        Sink<Double> opWrapSink(int flags, Sink<Double> sink) {
            return new Sink.ChainedDouble<Double>(sink) {
                @Override
                public void accept(double t) {
                    action.accept(t);
                    downstream.accept(t);
                }
            };
        }
    };
}

@Override
public boolean tryAdvance(DoubleConsumer action) {
    boolean test = true;
    if (takeOrDrop &&               // If can take
        checkCancelOnCount() && // and if not cancelled
        s.tryAdvance(this) &&   // and if advanced one element
        (test = p.test(t))) {   // and test on element passes
        action.accept(t);           // then accept element
        return true;
    }
    else {
        // Taking is finished
        takeOrDrop = false;
        // Cancel all further traversal and splitting operations
        // only if test of element failed (short-circuited)
        if (!test)
            cancel.set(true);
        return false;
    }
}

@Test(dataProvider = "DoubleSpinedBuffer", groups = { "serialization-hostile" })
public void testLongLastSplit(double[] array, SpinedBuffer.OfDouble sb) {
    Spliterator.OfDouble spliterator = sb.spliterator();
    Spliterator.OfDouble split = spliterator.trySplit();
    long splitSizes = (split == null) ? 0 : split.getExactSizeIfKnown();
    long lastSplitSize = spliterator.getExactSizeIfKnown();
    splitSizes += lastSplitSize;

    assertEquals(splitSizes, array.length);

    List<Double> contentOfLastSplit = new ArrayList<>();
    spliterator.forEachRemaining((DoubleConsumer) contentOfLastSplit::add);

    assertEquals(contentOfLastSplit.size(), lastSplitSize);

    List<Double> end = Arrays.stream(array)
            .boxed()
            .skip(array.length - lastSplitSize)
            .collect(Collectors.toList());
    assertEquals(contentOfLastSplit, end);
}

@Test(dataProvider = "Node.Builder<Double>")
public void testDoubleIteration(List<Double> l, Function<Integer, Node.Builder.OfDouble> m) {
    Node.Builder.OfDouble nb = m.apply(l.size());
    nb.begin(l.size());
    for (Double i : l) {
        nb.accept((double) i);
    }
    nb.end();

    Node.OfDouble n = nb.build();
    assertEquals(n.count(), l.size());

    {
        List<Double> _l = new ArrayList<>();
        n.forEach((DoubleConsumer) _l::add);

        assertContents(_l, l);
    }

}

@Override
default Node.OfDouble truncate(long from, long to, IntFunction<Double[]> generator) {
    if (from == 0 && to == count())
        return this;
    long size = to - from;
    Spliterator.OfDouble spliterator = spliterator();
    Node.Builder.OfDouble nodeBuilder = Nodes.doubleBuilder(size);
    nodeBuilder.begin(size);
    for (int i = 0; i < from && spliterator.tryAdvance((DoubleConsumer) e -> { }); i++) { }
    if (to == count()) {
        spliterator.forEachRemaining((DoubleConsumer) nodeBuilder);
    } else {
        for (int i = 0; i < size && spliterator.tryAdvance((DoubleConsumer) nodeBuilder); i++) { }
    }
    nodeBuilder.end();
    return nodeBuilder.build();
}

public void testDoubleForEachRemainingWithNull() {
    PrimitiveIterator.OfDouble i = new PrimitiveIterator.OfDouble() {
        @Override
        public double nextDouble() {
            return 0;
        }

        @Override
        public boolean hasNext() {
            return false;
        }
    };

    assertThrowsNPE(() -> i.forEachRemaining((DoubleConsumer) null));
    assertThrowsNPE(() -> i.forEachRemaining((Consumer<Double>) null));
}

private void animateValue(double from,
                          double to,
                          Duration duration,
                          Interpolator interpolator, DoubleConsumer consumer,
                          EventHandler<ActionEvent> l) {
    timeline.stop();
    timeline.getKeyFrames().clear();
    KeyValue keyValue = new KeyValue(new WritableValue<Double>() {
        @Override
        public Double getValue() {
            return from;
        }
        @Override
        public void setValue(Double value) {
            consumer.accept(value);
        }
    }, to, interpolator == null ? Interpolator.LINEAR : interpolator);
    timeline.getKeyFrames().add(new KeyFrame(duration, keyValue));
    timeline.setOnFinished(l);
    timeline.play();
}

public void forEachRemaining(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        index = f;
        Random r = rng;
        double o = origin, b = bound;
        do {
            consumer.accept(r.internalNextDouble(o, b));
        } while (++i < f);
    }
}

@Override
public void forEachOrdered(DoubleConsumer consumer) {
    if (!isParallel()) {
        adapt(sourceStageSpliterator()).forEachRemaining(consumer);
    }
    else {
        super.forEachOrdered(consumer);
    }
}

public boolean tryAdvance(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(ThreadLocalRandom.current().internalNextDouble(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
public void testDoubleOps(String name, final TestData.OfDouble data) {
    class RecordingConsumer extends AbstractRecordingConsumer<Double> implements DoubleConsumer {
        public void accept(double t) {
            list.add(t);
        }
    }
    final RecordingConsumer b = new RecordingConsumer();

    withData(data)
            .stream(s -> s.peek(b))
            .before(b::before)
            .after(b::after)
            .exercise();
}

@Test(dataProvider = "DoubleStreamTestData", dataProviderClass = DoubleStreamTestDataProvider.class)
public void testDoubleOps(String name, final TestData.OfDouble data) {
    class RecordingConsumer extends AbstractRecordingConsumer<Double> implements DoubleConsumer {
        public void accept(double t) {
            list.add(t);
        }
    }
    final RecordingConsumer b = new RecordingConsumer();

    withData(data)
            .stream(s -> s.peek(b))
            .before(b::before)
            .after(b::after)
            .exercise();
}

/**
 * Creates an {@code PrimitiveIterator.OfDouble} from a
 * {@code Spliterator.OfDouble}.
 *
 * <p>Traversal of elements should be accomplished through the iterator.
 * The behaviour of traversal is undefined if the spliterator is operated
 * after the iterator is returned.
 *
 * @param spliterator The spliterator
 * @return An iterator
 * @throws NullPointerException if the given spliterator is {@code null}
 */
public static PrimitiveIterator.OfDouble iterator(Spliterator.OfDouble spliterator) {
    Objects.requireNonNull(spliterator);
    class Adapter implements PrimitiveIterator.OfDouble, DoubleConsumer {
        boolean valueReady = false;
        double nextElement;

        @Override
        public void accept(double t) {
            valueReady = true;
            nextElement = t;
        }

        @Override
        public boolean hasNext() {
            if (!valueReady)
                spliterator.tryAdvance(this);
            return valueReady;
        }

        @Override
        public double nextDouble() {
            if (!valueReady && !hasNext())
                throw new NoSuchElementException();
            else {
                valueReady = false;
                return nextElement;
            }
        }
    }

    return new Adapter();
}

public boolean autoMatchFields(ClassifierLevel level, double absThreshold, double relThreshold, DoubleConsumer progressReceiver) {
    AtomicInteger totalUnmatched = new AtomicInteger();
    Map<FieldInstance, FieldInstance> matches = match(level, absThreshold, relThreshold, cls -> cls.getFields(), FieldClassifier::rank, progressReceiver, totalUnmatched);

    for (Map.Entry<FieldInstance, FieldInstance> entry : matches.entrySet()) {
        match(entry.getKey(), entry.getValue());
    }

    System.out.println("Auto matched "+matches.size()+" fields ("+totalUnmatched.get()+" unmatched)");

    return !matches.isEmpty();
}

@Override
public boolean tryAdvance(DoubleConsumer action) {
    if (action == null)
        throw new NullPointerException();
    if (index >= 0 && index < fence) {
        action.accept(array[index++]);
        return true;
    }
    return false;
}

private long run_benchmark(long iterations, DoubleConsumer test) {
    long seed = 12345;
    Random rand = new Random();
    rand.setSeed(seed);

    long startTime = System.nanoTime();
    for(int i = 0; i < iterations; i++) {
        test.accept(rand.nextDouble());
    }

    long endTime = System.nanoTime();
    return TimeUnit.MILLISECONDS.convert(endTime - startTime, TimeUnit.NANOSECONDS);
}

@Override
public boolean tryAdvance(DoubleConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
        return true;
    }
    else {
        return false;
    }
}

public boolean tryAdvance(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(rng.internalNextDouble(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

@Override
public void forEach(DoubleConsumer consumer) {
    if (!isParallel()) {
        adapt(sourceStageSpliterator()).forEachRemaining(consumer);
    }
    else {
        super.forEach(consumer);
    }
}

@Override
public void forEachOrdered(DoubleConsumer consumer) {
    if (!isParallel()) {
        adapt(sourceStageSpliterator()).forEachRemaining(consumer);
    }
    else {
        super.forEachOrdered(consumer);
    }
}

@Override
public void forEach(Consumer<? super Double> consumer) {
    if (consumer instanceof DoubleConsumer) {
        forEach((DoubleConsumer) consumer);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} calling SpinedBuffer.OfDouble.forEach(Consumer)");
        spliterator().forEachRemaining(consumer);
    }
}

@Override
protected void arrayForEach(double[] array,
                            int from, int to,
                            DoubleConsumer consumer) {
    for (int i = from; i < to; i++)
        consumer.accept(array[i]);
}

@Override
protected void arrayForEach(double[] array,
                            int from, int to,
                            DoubleConsumer consumer) {
    for (int i = from; i < to; i++)
        consumer.accept(array[i]);
}

public boolean tryAdvance(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(rng.internalNextDouble(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

@Override
public boolean tryAdvance(DoubleConsumer consumer) {
    Objects.requireNonNull(consumer);
    boolean hasNext = doAdvance();
    if (hasNext)
        consumer.accept(buffer.get(nextToConsume));
    return hasNext;
}

@Override
public boolean tryAdvance(DoubleConsumer action) {
    Objects.requireNonNull(action);

    action.accept(s.getAsDouble());
    return true;
}

@Override
public boolean tryAdvance(DoubleConsumer action) {
    Objects.requireNonNull(action);

    if (count == -2) {
        action.accept(first);
        count = -1;
        return true;
    }
    else {
        return false;
    }
}

/**
 * Creates an {@code PrimitiveIterator.OfDouble} from a
 * {@code Spliterator.OfDouble}.
 *
 * <p>Traversal of elements should be accomplished through the iterator.
 * The behaviour of traversal is undefined if the spliterator is operated
 * after the iterator is returned.
 *
 * @param spliterator The spliterator
 * @return An iterator
 * @throws NullPointerException if the given spliterator is {@code null}
 */
public static PrimitiveIterator.OfDouble iterator(Spliterator.OfDouble spliterator) {
    Objects.requireNonNull(spliterator);
    class Adapter implements PrimitiveIterator.OfDouble, DoubleConsumer {
        boolean valueReady = false;
        double nextElement;

        @Override
        public void accept(double t) {
            valueReady = true;
            nextElement = t;
        }

        @Override
        public boolean hasNext() {
            if (!valueReady)
                spliterator.tryAdvance(this);
            return valueReady;
        }

        @Override
        public double nextDouble() {
            if (!valueReady && !hasNext())
                throw new NoSuchElementException();
            else {
                valueReady = false;
                return nextElement;
            }
        }
    }

    return new Adapter();
}

@Override
default Node.OfDouble truncate(long from, long to, IntFunction<Double[]> generator) {
    if (from == 0 && to == count())
        return this;
    long size = to - from;
    Spliterator.OfDouble spliterator = spliterator();
    Node.Builder.OfDouble nodeBuilder = Nodes.doubleBuilder(size);
    nodeBuilder.begin(size);
    for (int i = 0; i < from && spliterator.tryAdvance((DoubleConsumer) e -> { }); i++) { }
    for (int i = 0; (i < size) && spliterator.tryAdvance((DoubleConsumer) nodeBuilder); i++) { }
    nodeBuilder.end();
    return nodeBuilder.build();
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code DoubleConsumer} then it is
 * cast to {@code DoubleConsumer} and passed to
 * {@link #forEachRemaining}; otherwise the action is adapted to
 * an instance of {@code DoubleConsumer}, by boxing the argument of
 * {@code DoubleConsumer}, and then passed to
 * {@link #forEachRemaining}.
 */
@Override
default void forEachRemaining(Consumer<? super Double> action) {
    if (action instanceof DoubleConsumer) {
        forEachRemaining((DoubleConsumer) action);
    }
    else {
        // The method reference action::accept is never null
        Objects.requireNonNull(action);
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(), "{0} calling PrimitiveIterator.OfDouble.forEachRemainingDouble(action::accept)");
        forEachRemaining((DoubleConsumer) action::accept);
    }
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code DoubleConsumer} then it is
 * cast to {@code DoubleConsumer} and passed to
 * {@link #tryAdvance(java.util.function.DoubleConsumer)}; otherwise
 * the action is adapted to an instance of {@code DoubleConsumer}, by
 * boxing the argument of {@code DoubleConsumer}, and then passed to
 * {@link #tryAdvance(java.util.function.DoubleConsumer)}.
 */
@Override
default boolean tryAdvance(Consumer<? super Double> action) {
    if (action instanceof DoubleConsumer) {
        return tryAdvance((DoubleConsumer) action);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(),
                          "{0} calling Spliterator.OfDouble.tryAdvance((DoubleConsumer) action::accept)");
        return tryAdvance((DoubleConsumer) action::accept);
    }
}

/**
 * {@inheritDoc}
 * @implSpec
 * If the action is an instance of {@code DoubleConsumer} then it is
 * cast to {@code DoubleConsumer} and passed to
 * {@link #forEachRemaining(java.util.function.DoubleConsumer)};
 * otherwise the action is adapted to an instance of
 * {@code DoubleConsumer}, by boxing the argument of
 * {@code DoubleConsumer}, and then passed to
 * {@link #forEachRemaining(java.util.function.DoubleConsumer)}.
 */
@Override
default void forEachRemaining(Consumer<? super Double> action) {
    if (action instanceof DoubleConsumer) {
        forEachRemaining((DoubleConsumer) action);
    }
    else {
        if (Tripwire.ENABLED)
            Tripwire.trip(getClass(),
                          "{0} calling Spliterator.OfDouble.forEachRemaining((DoubleConsumer) action::accept)");
        forEachRemaining((DoubleConsumer) action::accept);
    }
}

public boolean tryAdvance(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        consumer.accept(rng.internalNextDouble(origin, bound));
        index = i + 1;
        return true;
    }
    return false;
}

public void forEachRemaining(DoubleConsumer consumer) {
    if (consumer == null) throw new NullPointerException();
    long i = index, f = fence;
    if (i < f) {
        index = f;
        Random r = rng;
        double o = origin, b = bound;
        do {
            consumer.accept(r.internalNextDouble(o, b));
        } while (++i < f);
    }
}