@Override public DoubleSummaryStatistics execute() { try (final DoubleStream stream = buildPrevious()) { return stream.summaryStatistics(); } } }
default DoubleSummaryStatistics summaryStatistics(DoublePipeline pipeline) { requireNonNull(pipeline); return optimize(pipeline).getAsDoubleStream().summaryStatistics(); }
public static LimitOrder adaptOrder(BTCMarketsOrder o) { BigDecimal averagePrice = BigDecimal.valueOf( o.getTrades() .stream() .mapToDouble(value -> value.getPrice().doubleValue()) .summaryStatistics() .getAverage()); BigDecimal fee = BigDecimal.valueOf( o.getTrades().stream().mapToDouble(value -> value.getFee().doubleValue()).sum()); BigDecimal cumulativeAmount = BigDecimal.valueOf( o.getTrades().stream().mapToDouble(value -> value.getVolume().doubleValue()).sum()); return new LimitOrder( adaptOrderType(o.getOrderSide()), o.getVolume(), new CurrencyPair(o.getInstrument(), o.getCurrency()), Long.toString(o.getId()), o.getCreationTime(), o.getPrice(), averagePrice, cumulativeAmount, fee, adaptOrderStatus(o.getStatus())); }
public void testEquivalentStreams() { // For datasets of many double values created from an array, we test many combinations of finite // and non-finite values: for (ManyValues values : ALL_MANY_VALUES) { double[] array = values.asArray(); Stats stats = Stats.of(array); // instance methods on Stats vs on instance methods on DoubleStream assertThat(stats.count()).isEqualTo(stream(array).count()); assertEquivalent(stats.mean(), stream(array).average().getAsDouble()); assertEquivalent(stats.sum(), stream(array).sum()); assertEquivalent(stats.max(), stream(array).max().getAsDouble()); assertEquivalent(stats.min(), stream(array).min().getAsDouble()); // static method on Stats vs on instance method on DoubleStream assertEquivalent(Stats.meanOf(array), stream(array).average().getAsDouble()); // instance methods on Stats vs instance methods on DoubleSummaryStatistics DoubleSummaryStatistics streamStats = stream(array).summaryStatistics(); assertThat(stats.count()).isEqualTo(streamStats.getCount()); assertEquivalent(stats.mean(), streamStats.getAverage()); assertEquivalent(stats.sum(), streamStats.getSum()); assertEquivalent(stats.max(), streamStats.getMax()); assertEquivalent(stats.min(), streamStats.getMin()); } }
public MetaScores(List<Double> scores) { // A meta alert could be entirely alerts with no values. DoubleSummaryStatistics stats = scores .stream() .mapToDouble(a -> a) .summaryStatistics(); metaScores.put("max", stats.getMax()); metaScores.put("min", stats.getMin()); metaScores.put("average", stats.getAverage()); metaScores.put("count", stats.getCount()); metaScores.put("sum", stats.getSum()); // median isn't in the stats summary double[] arr = scores .stream() .mapToDouble(d -> d) .toArray(); metaScores.put("median", new Median().evaluate(arr)); }
@Override public DoubleSummaryStatistics summaryStatistics() { return stream.summaryStatistics(); }
/** * @param collection * The collection of items * @return A state object for collecting statistics such as count, min, max, sum, and average. */ public static DoubleSummaryStatistics summarizingDouble(final Collection<Double> collection) { return collection.stream().mapToDouble(value -> value).summaryStatistics(); }
@Override public DoubleSummaryStatistics summaryStatistics() { // This is a terminal operation return evalAndclose(() -> stream.summaryStatistics()); }
/** * Sum double. * * @return the double */ public double sum() { final DoubleSummaryStatistics statistics = Arrays.stream(data).summaryStatistics(); return statistics.getSum(); }
double[] array = {1, 2, 3, 5, 3}; DoubleSummaryStatistics stats = Arrays.stream(array).summaryStatistics(); System.out.println(stats.getMax()); System.out.println(stats.getAverage());
double array[] = new double[numOfElements]; DoubleSummaryStatistics dss = Arrays.stream(array).summaryStatistics(); System.out.println("average " + dss.getAverage()); System.out.println("sum " + dss.getSum());
/** * Sum sq double. * * @return the double */ public double sumSq() { final DoubleStream doubleStream = Arrays.stream(data).map((final double x) -> x * x); final DoubleSummaryStatistics statistics = doubleStream.summaryStatistics(); return statistics.getSum(); } }
@Override public void copy(@Nonnull double[] from, @Nonnull byte[] to) { DoubleSummaryStatistics statistics = Arrays.stream(from).summaryStatistics(); @Nonnull DoubleBuffer inBuffer = DoubleBuffer.wrap(from); @Nonnull FloatBuffer floatBuffer = ByteBuffer.wrap(to).asFloatBuffer(); double min = statistics.getMin(); double max = statistics.getMax(); floatBuffer.put((float) min); floatBuffer.put((float) max); double center = (max + min) / 2; double radius = (max - min) / 2; @Nonnull IntBuffer byteBuffer = ByteBuffer.wrap(to).asIntBuffer(); byteBuffer.position(2); while (inBuffer.hasRemaining()) { byteBuffer.put((int) (Integer.MAX_VALUE * (inBuffer.get() - center) / radius)); } }
default DoubleSummaryStatistics summaryStatistics(DoublePipeline pipeline) { requireNonNull(pipeline); return optimize(pipeline).getAsDoubleStream().summaryStatistics(); }
@Override public void copy(@Nonnull double[] from, @Nonnull byte[] to) { DoubleSummaryStatistics statistics = Arrays.stream(from).summaryStatistics(); @Nonnull DoubleBuffer inBuffer = DoubleBuffer.wrap(from); @Nonnull FloatBuffer floatBuffer = ByteBuffer.wrap(to).asFloatBuffer(); double min = statistics.getMin(); double max = statistics.getMax(); floatBuffer.put((float) min); floatBuffer.put((float) max); double center = (max + min) / 2; double radius = (max - min) / 2; @Nonnull ByteBuffer byteBuffer = ByteBuffer.wrap(to); byteBuffer.position(8); while (inBuffer.hasRemaining()) { byteBuffer.put((byte) (Byte.MAX_VALUE * (inBuffer.get() - center) / radius)); } }
@Override public void copy(@Nonnull double[] from, @Nonnull byte[] to) { DoubleSummaryStatistics statistics = Arrays.stream(from).summaryStatistics(); @Nonnull DoubleBuffer inBuffer = DoubleBuffer.wrap(from); @Nonnull FloatBuffer floatBuffer = ByteBuffer.wrap(to).asFloatBuffer(); double min = statistics.getMin(); double max = statistics.getMax(); floatBuffer.put((float) min); floatBuffer.put((float) max); double center = (max + min) / 2; double radius = (max - min) / 2; @Nonnull ShortBuffer shortBuffer = ByteBuffer.wrap(to).asShortBuffer(); shortBuffer.position(4); while (inBuffer.hasRemaining()) { shortBuffer.put((short) (Short.MAX_VALUE * (inBuffer.get() - center) / radius)); } }
/** * Dot double. * * @param right the right * @return the double */ public double dot(@Nonnull final DoubleBuffer<K> right) { if (this.target != right.target) { throw new IllegalArgumentException(String.format("Deltas are not based on same buffer. %s != %s", this.layer, right.layer)); } if (!this.layer.equals(right.layer)) { throw new IllegalArgumentException(String.format("Deltas are not based on same layer. %s != %s", this.layer, right.layer)); } @Nullable final double[] l = this.getDelta(); @Nullable final double[] r = right.getDelta(); assert l.length == r.length; final double[] array = IntStream.range(0, l.length).mapToDouble(i -> l[i] * r[i]).toArray(); return Arrays.stream(array).summaryStatistics().getSum(); }
private DoubleSummaryStatistics getYPositionStatistics() { if (Objects.isNull(yPositionStatistics)) { yPositionStatistics = Stream.concat(clipboardControl.getElements().stream() .filter(element -> element instanceof Node) .map(element -> ((View) element.getContent()).getBounds().getLowerRight()), clipboardControl.getElements().stream().filter(element -> element instanceof Node) .map(element -> ((View) element.getContent()).getBounds().getUpperLeft())).mapToDouble(bound -> bound.getY()).summaryStatistics(); } return yPositionStatistics; }
/** * Print history. * * @param log the logger * @param history the history */ public static void printHistory(@Nonnull final NotebookOutput log, @Nonnull final List<StepRecord> history) { if (!history.isEmpty()) { log.out("Convergence Plot: "); log.eval(() -> { final DoubleSummaryStatistics valueStats = history.stream().mapToDouble(x -> x.fitness).filter(x -> x > 0).summaryStatistics(); @Nonnull final PlotCanvas plot = ScatterPlot.plot(history.stream().map(step -> new double[]{step.iteration, Math.log10(Math.max(valueStats.getMin(), step.fitness))}) .toArray(i -> new double[i][])); plot.setTitle("Convergence Plot"); plot.setAxisLabels("Iteration", "log10(Fitness)"); plot.setSize(600, 400); return plot; }); } }
/** * Perform an asynchronous summaryStatistics operation * @see java.util.stream.Stream#mapToDouble(ToDoubleFunction) * @see java.util.stream.DoubleStream#summaryStatistics() * */ default CompletableFuture<DoubleSummaryStatistics> summaryStatisticsDouble(ToDoubleFunction<? super T> fn){ return CompletableFuture.supplyAsync(()->getStream() .flatMapToDouble(t-> DoubleStream.of(fn.applyAsDouble(t))) .summaryStatistics(),getExec()); } }