public DoubleFilterAction(DoublePredicate predicate) { super(s -> s.filter(requireNonNull(predicate)), DoubleStream.class, FILTER); }
private int fragmentedCpu() { Double res = nodeIdToResources.get().values().parallelStream().filter(this::isFragmented) .mapToDouble(SupervisorResources::getAvailableCpu).filter(x -> x > 0).sum(); return res.intValue(); }
double[] d = {8, 7, -6, 5, -4}; d = Arrays.stream(d).filter(x -> x > 0).toArray(); //d => [8, 7, 5]
private double fragmentedMemory() { Double res = nodeIdToResources.get().values().parallelStream().filter(this::isFragmented) .mapToDouble(SupervisorResources::getAvailableMem).filter(x -> x > 0).sum(); return res.intValue(); }
@Override public DoubleStream build(boolean parallel) { return previous().build(parallel).filter(predicate); } }
@Override public DoubleStream filter(DoublePredicate predicate) { return wrap(stream().filter(predicate)); }
/** * Get new statistics that excludes values beyond mean +/- 2 * stdev * * @param data Source data * @return new {@link @DescriptiveStatistics objects with sanitized data} */ private static DescriptiveStatistics sanitize(@NotNull DescriptiveStatistics data) { double meanValue = data.getMean(); double delta = MARGIN * meanValue; double minVal = meanValue - delta; double maxVal = meanValue + delta; return new DescriptiveStatistics(Arrays.stream(data.getValues()) .filter(x -> x > minVal && x < maxVal) .toArray()); }
@Deprecated //moved to cyclops.companion.Functions public static Function<? super ReactiveSeq<Double>, ? extends ReactiveSeq<Double>> filterLongs(DoublePredicate b){ return a->a.doubles(i->i,s->s.filter(b)); } /*
public static Function<? super ReactiveSeq<Double>, ? extends ReactiveSeq<Double>> filterLongs(DoublePredicate b){ return a->a.doubles(i->i,s->s.filter(b)); } /*
@Test public void doubles(){ assertThat(ReactiveSeq.range(1, 1000).doubles(i->i.doubleValue(),s->s.map(i->i*2).filter(i->i<500)) .size(),equalTo(249)); } @Test
private static double roundLambda(double n, double[] a) { double[] r = {0}, d = {Double.MAX_VALUE}; Arrays.stream(a).filter((i)->Math.abs(i-n)<d[0]).forEach(i->{d[0]=Math.abs(i-n);r[0]=i;}); return r[0]; }
@Deprecated //moved to cyclops.companion.Functions public static Function<? super ReactiveSeq<Double>, ? extends ReactiveSeq<Double>> filterLongs(DoublePredicate b){ return a->a.doubles(i->i,s->s.filter(b)); } /*
@Override public double evaluate(double[] values) throws MathIllegalArgumentException { long below = Arrays.stream(values) .filter(val -> val <= threshold) .count(); return (double) below / values.length; }
public double averageRAM() { return tpsData.stream() .mapToDouble(TPS::getUsedMemory) .filter(num -> num >= 0) .average().orElse(-1); }
public double averageCPU() { return tpsData.stream() .mapToDouble(TPS::getCPUUsage) .filter(num -> num >= 0) .average().orElse(-1); }
public double averageEntities() { return tpsData.stream() .mapToDouble(TPS::getEntityCount) .filter(num -> num >= 0) .average().orElse(-1); }
public double averageFreeDisk() { return tpsData.stream() .mapToDouble(TPS::getFreeDiskSpace) .filter(num -> num >= 0) .average().orElse(-1); }
public double average() { return pings.stream().mapToDouble(Ping::getAverage) .filter(value -> value > 0 && value <= 4000) .average().orElse(-1); } }
@Override public double evaluate(double[] values, int begin, int length) throws MathIllegalArgumentException { long below = IntStream.range(begin, length) .mapToDouble(i -> values[i]) .filter(val -> val > threshold) .count(); return 100.0 * below / length; }
/** * Gets volume. * * @return the volume */ public double getVolume() { int dim = min.length; return IntStream.range(0, dim).mapToDouble(d -> { return max[d] - min[d]; }).filter(x -> Double.isFinite(x) && x > 0.0).reduce((a, b) -> a * b).orElse(Double.NaN); }