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

/**
 * Gets the best goods wish for a carrier unit.
 *
 * @param aiUnit The carrier {@code AIUnit}.
 * @param goodsType The {@code GoodsType} to wish for.
 * @return The best {@code GoodsWish} for the unit.
 */
public GoodsWish getBestGoodsWish(AIUnit aiUnit, GoodsType goodsType) {
    final Unit carrier = aiUnit.getUnit();
    final ToDoubleFunction<GoodsWish> wishValue
        = cacheDouble(gw -> {
                int turns = carrier.getTurnsToReach(carrier.getLocation(),
                                                    gw.getDestination());
                return (turns >= Unit.MANY_TURNS) ? -1.0
                    : (double)gw.getValue() / turns;
            });
    final Comparator<GoodsWish> comp
        = Comparator.comparingDouble(wishValue);

    List<GoodsWish> wishes = goodsWishes.get(goodsType);
    return (wishes == null) ? null
        : maximize(wishes, gw -> wishValue.applyAsDouble(gw) > 0.0, comp);
}

/**
 * Maps the specified column to doubles using the mapper function provided
 * @param frame     the frame reference
 * @param colKey    the column key to apply mapper function to
 * @param mapper    the mapper function to apply
 * @return          the newly created content, with update column
 */
@SuppressWarnings("unchecked")
final XDataFrameContent<R,C> mapToDoubles(XDataFrame<R,C> frame, C colKey, ToDoubleFunction<DataFrameValue<R,C>> mapper) {
    if (!isColumnStore()) {
        throw new DataFrameException("Cannot apply columns of a transposed DataFrame");
    } else {
        final int rowCount = rowKeys.size();
        final boolean parallel  = frame.isParallel();
        final int colIndex = colKeys.getIndexForKey(colKey);
        return new XDataFrameContent<>(rowKeys, colKeys, true, Mapper.apply(data, parallel, (index, array) -> {
            if (index != colIndex) {
                return array;
            } else {
                final int colOrdinal = colKeys.getOrdinalForKey(colKey);
                final Array<?> targetValues = Array.of(Double.class, array.length());
                final Cursor cursor = new Cursor(frame, rowKeys.isEmpty() ? -1 : 0, colOrdinal);
                for (int i = 0; i < rowCount; ++i) {
                    cursor.atRowOrdinal(i);
                    final double value = mapper.applyAsDouble(cursor);
                    targetValues.setDouble(cursor.rowIndex, value);
                }
                return targetValues;
            }
        }));
    }
}

private static <A extends Annotation, E extends Throwable> double callDouble(
        AnnotationInterceptor<A> annotationInterceptor,
        int annotationId, A[] annotations, CallContext context, Arguments currentArguments,
        ToDoubleFunction<Arguments> terminalInvokeFun) throws E {

    A annotation = annotations[annotationId];
    if (annotationId == annotations.length - 1) { // last annotation
        return annotationInterceptor.onCall(annotation, context,
                new SimpleDoubleInterceptionHandler(currentArguments, terminalInvokeFun));
    } else {
        return annotationInterceptor.onCall(annotation, context,
                new SimpleDoubleInterceptionHandler(currentArguments,
                        (args) -> callDouble(annotationInterceptor, annotationId + 1, annotations, context, args,
                                terminalInvokeFun)));
    }
}

/**
 * Returns a {@code Collector} that produces the sum of a double-valued
 * function applied to the input elements.  If no elements are present,
 * the result is 0.
 *
 * <p>The sum returned can vary depending upon the order in which
 * values are recorded, due to accumulated rounding error in
 * addition of values of differing magnitudes. Values sorted by increasing
 * absolute magnitude tend to yield more accurate results.  If any recorded
 * value is a {@code NaN} or the sum is at any point a {@code NaN} then the
 * sum will be {@code NaN}.
 *
 * @param <T> the type of the input elements
 * @param mapper a function extracting the property to be summed
 * @return a {@code Collector} that produces the sum of a derived property
 */
public static <T> Collector<T, ?, Double>
summingDouble(ToDoubleFunction<? super T> mapper) {
    /*
     * In the arrays allocated for the collect operation, index 0
     * holds the high-order bits of the running sum, index 1 holds
     * the low-order bits of the sum computed via compensated
     * summation, and index 2 holds the simple sum used to compute
     * the proper result if the stream contains infinite values of
     * the same sign.
     */
    return new CollectorImpl<>(
            () -> new double[3],
            (a, t) -> { double val = mapper.applyAsDouble(t);
                        sumWithCompensation(a, val);
                        a[2] += val;},
            (a, b) -> { sumWithCompensation(a, b[0]);
                        a[2] += b[2];
                        return sumWithCompensation(a, b[1]); },
            a -> computeFinalSum(a),
            CH_NOID);
}

public final void compute() {
    final ToDoubleFunction<? super V> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceValuesToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.val));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceValuesToDoubleTask<K,V>
                t = (MapReduceValuesToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

@Override
protected <T> io.micrometer.core.instrument.Gauge newGauge(Meter.Id id, T obj, ToDoubleFunction<T> f) {
    final WeakReference<T> ref = new WeakReference<>(obj);
    Gauge<Double> gauge = () -> {
        T obj2 = ref.get();
        return obj2 != null ? f.applyAsDouble(ref.get()) : Double.NaN;
    };
    registry.register(hierarchicalName(id), gauge);
    return new DropwizardGauge(id, gauge);
}

@Override
protected <T> FunctionTimer newFunctionTimer(Meter.Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnits) {
    DropwizardFunctionTimer ft = new DropwizardFunctionTimer<>(id, clock, obj, countFunction, totalTimeFunction,
        totalTimeFunctionUnits, getBaseTimeUnit());
    registry.register(hierarchicalName(id), ft.getDropwizardMeter());
    return ft;
}

@Override()
public final Z applyDoubles(ToDoubleFunction<DataFrameValue<R,C>> mapper) {
    return forEachValue(value -> {
        final double result = mapper.applyAsDouble(value);
        value.setDouble(result);
    });
}

public final void compute() {
    final ToDoubleFunction<? super K> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceKeysToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceKeysToDoubleTask<K,V>
                t = (MapReduceKeysToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

/**
 * A timer that tracks monotonically increasing functions for count and totalTime.
 */
public <T> FunctionTimer timer(String name, Iterable<Tag> tags, T obj,
                               ToLongFunction<T> countFunction,
                               ToDoubleFunction<T> totalTimeFunction,
                               TimeUnit totalTimeFunctionUnits) {
    return globalRegistry.more().timer(name, tags, obj, countFunction, totalTimeFunction, totalTimeFunctionUnits);
}

private Builder(String name, T obj,
                ToLongFunction<T> countFunction,
                ToDoubleFunction<T> totalTimeFunction,
                TimeUnit totalTimeFunctionUnits) {
    this.name = name;
    this.obj = obj;
    this.countFunction = countFunction;
    this.totalTimeFunction = totalTimeFunction;
    this.totalTimeFunctionUnits = totalTimeFunctionUnits;
}

private void counter(MeterRegistry registry, String name, String description, ToDoubleFunction<Statistics> f, String... extraTags) {
    FunctionCounter.builder(name, stats, f)
        .tags(tags)
        .tags(extraTags)
        .description(description)
        .register(registry);
}

public final void compute() {
    final ToDoubleFunction<? super K> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceKeysToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceKeysToDoubleTask<K,V>
                t = (MapReduceKeysToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

private void buildStatusCounter(MeterRegistry reg, String status, ToDoubleFunction<StatisticsHandler> consumer) {
    FunctionCounter.builder("jetty.responses", statisticsHandler, consumer)
        .tags(tags)
        .description("Number of requests with response status")
        .tags("status", status)
        .register(reg);
}

/**
 * Creates an DOUBLE mapper that wraps to function provided
 * @param function  the function to wrap
 * @param <I>       the input type
 * @return          the newly created mapper
 */
public static <I,O> Function1<I,Double> toDouble(ToDoubleFunction<I> function) {
    return new Function1<I,Double>(FunctionStyle.DOUBLE) {
        @Override
        public final double applyAsDouble(I value) {
            return function.applyAsDouble(value);
        }
    };
}

StatsdFunctionTimer(Id id, T obj, ToLongFunction<T> countFunction, ToDoubleFunction<T> totalTimeFunction,
                    TimeUnit totalTimeFunctionUnits, TimeUnit baseTimeUnit,
                    StatsdLineBuilder lineBuilder, Subscriber<String> publisher) {
    super(id, obj, countFunction, totalTimeFunction, totalTimeFunctionUnits, baseTimeUnit);
    this.lineBuilder = lineBuilder;
    this.publisher = publisher;
}

@Override
public final Array<Double> mapToDoubles(ToDoubleFunction<ArrayValue<T>> mapper) {
    final Array<Double> result = Array.of(Double.class, length());
    final MapValues<Double> action = new MapValues<>(0, length() - 1, mapper, result);
    if (isParallel()) {
        ForkJoinPool.commonPool().invoke(action);
        return result;
    } else {
        action.compute();
        return result;
    }
}

@SuppressWarnings("unchecked")
@Override
protected <T> io.micrometer.core.instrument.Gauge newGauge(Meter.Id id, T obj, ToDoubleFunction<T> f) {
    MicrometerCollector collector = collectorByName(id, Collector.Type.GAUGE);
    Gauge gauge = new DefaultGauge(id, obj, f);
    List<String> tagValues = tagValues(id);

    collector.add((conventionName, tagKeys) -> Stream.of(
        new Collector.MetricFamilySamples.Sample(conventionName, tagKeys, tagValues, gauge.value())
    ));

    return gauge;
}

@Override
public final Array<T> applyDoubles(ToDoubleFunction<ArrayValue<T>> function) {
    final int length = length();
    if (length > 0) {
        final ApplyValues action = new ApplyValues(0, length - 1, function);
        if (isParallel()) {
            ForkJoinPool.commonPool().invoke(action);
        } else {
            action.compute();
        }
    }
    return this;
}

@Override
protected <T> FunctionCounter newFunctionCounter(Meter.Id id, T obj, ToDoubleFunction<T> f) {
    MicrometerCollector collector = collectorByName(id, Collector.Type.COUNTER);
    FunctionCounter fc = new CumulativeFunctionCounter<>(id, obj, f);
    List<String> tagValues = tagValues(id);

    collector.add((conventionName, tagKeys) -> Stream.of(
        new Collector.MetricFamilySamples.Sample(conventionName, tagKeys, tagValues, fc.count())
    ));

    return fc;
}

/**
 * Creates a subsource for a specific motor in a drive base.
 *
 * @param source    the source for the drive base data
 * @param motorName the motor name (eg "Left Motor" or "Right Motor")
 * @param getter    the getter (eg {@code DifferentialDriveData::getLeftSpeed})
 * @param setter    the setter (eg {@code DifferentialDriveData::withLeftSpeed})
 */
protected DataSource<SpeedControllerData> motorSource(DataSource<T> source,
                                                      String motorName,
                                                      ToDoubleFunction<T> getter,
                                                      BiFunction<T, Double, T> setter) {
  return new SubSource<>(
      SpeedControllerType.Instance,
      source,
      d -> setter.apply(dataOrDefault.get(), d == null ? 0.0 : d.getValue()),
      d -> new SpeedControllerData(motorName, d == null ? 0.0 : getter.applyAsDouble(d))
  );
}

private static <E extends Throwable> double callDouble(int interceptorId, Interceptor[] interceptors,
        CallContext context, Arguments currentArguments, ToDoubleFunction<Arguments> terminalInvokeFun) throws E {
    Interceptor interceptor = interceptors[interceptorId];
    if (interceptorId == interceptors.length - 1) { // last interceptor
        return interceptor.onCall(context,
                new SimpleDoubleInterceptionHandler(currentArguments, terminalInvokeFun));
    } else {
        return interceptor.onCall(context, new SimpleDoubleInterceptionHandler(currentArguments,
                (args) -> callDouble(interceptorId + 1, interceptors, context, args, terminalInvokeFun)));
    }
}

public final void compute() {
    final ToDoubleFunction<Map.Entry<K,V>> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceEntriesToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceEntriesToDoubleTask<K,V>
                t = (MapReduceEntriesToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

MapReduceValuesToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceValuesToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super V> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

MapReduceKeysToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceKeysToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super K> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

MapReduceEntriesToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceEntriesToDoubleTask<K,V> nextRight,
     ToDoubleFunction<Map.Entry<K,V>> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

MapReduceValuesToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceValuesToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super V> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

MapReduceKeysToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceKeysToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super K> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

MapReduceKeysToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceKeysToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super K> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

public final void compute() {
    final ToDoubleFunction<? super K> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceKeysToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.key));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceKeysToDoubleTask<K,V>
                t = (MapReduceKeysToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

MapReduceValuesToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceValuesToDoubleTask<K,V> nextRight,
     ToDoubleFunction<? super V> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

public final void compute() {
    final ToDoubleFunction<? super V> transformer;
    final DoubleBinaryOperator reducer;
    if ((transformer = this.transformer) != null &&
        (reducer = this.reducer) != null) {
        double r = this.basis;
        for (int i = baseIndex, f, h; batch > 0 &&
                 (h = ((f = baseLimit) + i) >>> 1) > i;) {
            addToPendingCount(1);
            (rights = new MapReduceValuesToDoubleTask<K,V>
             (this, batch >>>= 1, baseLimit = h, f, tab,
              rights, transformer, r, reducer)).fork();
        }
        for (Node<K,V> p; (p = advance()) != null; )
            r = reducer.applyAsDouble(r, transformer.applyAsDouble(p.val));
        result = r;
        CountedCompleter<?> c;
        for (c = firstComplete(); c != null; c = c.nextComplete()) {
            @SuppressWarnings("unchecked")
            MapReduceValuesToDoubleTask<K,V>
                t = (MapReduceValuesToDoubleTask<K,V>)c,
                s = t.rights;
            while (s != null) {
                t.result = reducer.applyAsDouble(t.result, s.result);
                s = t.rights = s.nextRight;
            }
        }
    }
}

MapReduceEntriesToDoubleTask
    (BulkTask<K,V,?> p, int b, int i, int f, Node<K,V>[] t,
     MapReduceEntriesToDoubleTask<K,V> nextRight,
     ToDoubleFunction<Map.Entry<K,V>> transformer,
     double basis,
     DoubleBinaryOperator reducer) {
    super(p, b, i, f, t); this.nextRight = nextRight;
    this.transformer = transformer;
    this.basis = basis; this.reducer = reducer;
}

@Override
public DoubleStream mapToDouble(ToDoubleFunction arg0) {
    return stream.mapToDouble(arg0);
}

@Override
public DoubleStream mapToDouble(final ToDoubleFunction<? super T> mapper) {
    return stream.mapToDouble(mapper);
}

public static <T> CalculatedDoubleValues calculateDouble(Collection<T> collection, ToDoubleFunction<T> toDouble) {
    return calculate(collection.stream().mapToDouble(toDouble));
}

@Override
public DataFrame<R,C> mapToDoubles(C colKey, ToDoubleFunction<DataFrameValue<R,C>> mapper) {
    return new XDataFrame<>(content().mapToDoubles(this, colKey, mapper), isParallel());
}

public CumulativeFunctionCounter(Meter.Id id, T obj, ToDoubleFunction<T> f) {
    super(id);
    this.ref = new WeakReference<>(obj);
    this.f = f;
}

static <T> Builder<T> builder(String name, T obj, ToDoubleFunction<T> f) {
    return new Builder<>(name, obj, f);
}

private Builder(String name, T obj, ToDoubleFunction<T> f) {
    this.name = name;
    this.obj = obj;
    this.f = f;
}