/** * Gets the the average value of best score array. * * @return The value. */ public double getBestAvgScore() { if (bestScore == null) return Double.MIN_VALUE; return Arrays.stream(bestScore).average().orElse(Double.MIN_VALUE); }
private int getNewTaskCount() { if (scheduledNodes.isEmpty()) { return 1; } double fullTasks = sourceTasksProvider.get().stream() .filter(task -> !task.getState().isDone()) .map(TaskStatus::isOutputBufferOverutilized) .mapToDouble(full -> full ? 1.0 : 0.0) .average().orElse(0.0); long writtenBytes = writerTasksProvider.get().stream() .map(TaskStatus::getPhysicalWrittenDataSize) .mapToLong(DataSize::toBytes) .sum(); if ((fullTasks >= 0.5) && (writtenBytes >= (writerMinSizeBytes * scheduledNodes.size()))) { return 1; } return 0; }
default OptionalDouble average(DoublePipeline pipeline) { requireNonNull(pipeline); return optimize(pipeline).getAsDoubleStream().average(); }
private Scope transition(LoadMapping load) { List<Integer> targetInScope = getTargetsInScope(currentScope); if (targetInScope.isEmpty()) { Scope upScope = Scope.upgrade(currentScope); if (upScope == currentScope) { throw new RuntimeException("The current scope " + currentScope + " has no target tasks."); } currentScope = upScope; return transition(load); } if (null == load) { return currentScope; } double avg = targetInScope.stream().mapToDouble((key) -> load.get(key)).average().getAsDouble(); Scope nextScope; if (avg < lowerBound) { nextScope = Scope.downgrade(currentScope); if (getTargetsInScope(nextScope).isEmpty()) { nextScope = currentScope; } } else if (avg > higherBound) { nextScope = Scope.upgrade(currentScope); } else { nextScope = currentScope; } return nextScope; }
return (clusterScatter1 + clusterScatter2) / distanceFn.applyAsDouble(centerI, centerJ); }).max().orElse(0.0); }).average().orElse(0.0);
final double locAvgScore = Arrays.stream(locScores).average().orElse(Double.MIN_VALUE);
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()); } }
double avg = Arrays.stream(y).average().orElse(0); for(int i = 0; i < result.length; i++) result[i] = avg; return new TrendResults(result, resultWidth, resultHeight);
default double stdDeviation(ToDoubleFunction<T> fn){ Seq<T> list = stream().seq(); double avg = list.collect(Collectors.<T>averagingDouble(fn)); return Math.sqrt( list.stream().mapToDouble(fn) .map(i->i-avg) .map(i->i*i) .average() .getAsDouble()); }
/** {@inheritDoc} */ @Override public Float getRT() { synchronized (features) { Collection<Feature> allFeatures = features.values(); float averageRt = (float) allFeatures.stream().mapToDouble(Feature::getRetentionTime) .average().getAsDouble(); return averageRt; } }
@Override public void endOverall() { double average = timings.stream() .mapToDouble(t -> t) .average() .getAsDouble(); resultsMap.put(testCaseEvent, average); logger.info("Average time: " + average); } }
@Override public Optional<Number> aggregate(List<? extends Number> values) { if (CollectionUtils.isEmpty(values)) { return Optional.empty(); } return Optional.of(values.stream().mapToDouble(Number::doubleValue).average().getAsDouble()); } }
@Override public OptionalDouble average() { // This is a terminal operation return evalAndclose(() -> stream.average()); }
public double averageTPS() { return tpsData.stream() .mapToDouble(TPS::getTicksPerSecond) .filter(num -> num >= 0) .average().orElse(-1); }
@Override public double error(FM fm, FMData test) { return test.stream() .mapToDouble(x -> error.error(fm, x)) .average().getAsDouble(); }
@Override public double error(FM fm, ListWiseFMData test) { return test.streamByGroup().map(Entry::getValue) .mapToDouble((List<? extends FMInstance> group) -> { double[] p = getP(group); double[] q = getQ(fm, group); return IntStream.range(0, group.size()) .mapToDouble(i -> -p[i] * log(q[i])) .sum(); }) .average().getAsDouble(); }
@Deprecated public static double overlap(MultiLabel[] multiLabels, MultiLabel[] predictions){ return IntStream.range(0,multiLabels.length).parallel() .mapToDouble(i -> overlap(multiLabels[i],predictions[i])) .average().getAsDouble(); }
/** * Perform an asynchronous average operation * @see java.util.stream.Stream#mapToDouble(ToDoubleFunction) * @see java.util.stream.DoubleStream#average() * */ default CompletableFuture<OptionalDouble> averageDouble(ToDoubleFunction<? super T> fn){ return CompletableFuture.supplyAsync(()->getStream() .flatMapToDouble(t-> DoubleStream.of(fn.applyAsDouble(t))) .average(),getExec()); } /**
private void outputStats(String indexName, String statsName, Function<PerfResult, Long> statsProvider, Collection<PerfResult> results) { double min = results.stream().mapToDouble(r -> statsProvider.apply(r) / (double) r.count).min().orElse(-1) / NANOS_TO_MILLIS; double max = results.stream().mapToDouble(r -> statsProvider.apply(r) / (double) r.count).max().orElse(-1) / NANOS_TO_MILLIS; double avg = results.stream().mapToDouble(r -> statsProvider.apply(r) / (double) r.count).average().orElse(-1) / NANOS_TO_MILLIS; System.out.println(String.format("%s.%s: Min = %.2f us, Max = %.2f us, Avg = %.2f us", indexName, statsName, min, max, avg)); }
public static double instanceMAP(MultiLabelClassifier.AssignmentProbEstimator classifier, MultiLabelClfDataSet dataSet, List<MultiLabel> combinations){ return IntStream.range(0, dataSet.getNumDataPoints()).parallel().mapToDouble(i->{ int[] binaryLabels = new int[classifier.getNumClasses()]; MultiLabel multiLabel = dataSet.getMultiLabels()[i]; for (int l:multiLabel.getMatchedLabels()) { binaryLabels[l] = 1; } double[] comProbs = classifier.predictAssignmentProbs(dataSet.getRow(i),combinations); double[] probs = Utils.marginals(combinations, comProbs, classifier.getNumClasses()); return AveragePrecision.averagePrecision(binaryLabels, probs); }).average().getAsDouble(); }