List of usage examples for java.util.function DoublePredicate test
boolean test(double value);
From source file:at.gridtec.lambda4j.function.bi.obj.ObjBooleanToFloatFunction.java
/** * Returns a composed {@link BiDoubleToFloatFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. If evaluation of either operation throws an exception, it is * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to * execute an operation which accepts {@code double} input, before this primitive function is executed. * * @param before1 The first function to apply before this function is applied * @param before2 The second predicate to apply before this function is applied * @return A composed {@code BiDoubleToFloatFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}./*from w w w.j a va 2 s. c o m*/ */ @Nonnull default BiDoubleToFloatFunction composeFromDouble(@Nonnull final DoubleFunction<? extends T> before1, @Nonnull final DoublePredicate before2) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); return (value1, value2) -> applyAsFloat(before1.apply(value1), before2.test(value2)); }
From source file:at.gridtec.lambda4j.function.bi.obj.ObjBooleanToLongFunction.java
/** * Returns a composed {@link BiDoubleToLongFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. If evaluation of either operation throws an exception, it is * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to * execute an operation which accepts {@code double} input, before this primitive function is executed. * * @param before1 The first function to apply before this function is applied * @param before2 The second predicate to apply before this function is applied * @return A composed {@code BiDoubleToLongFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}.//from w ww.j av a2s. c om */ @Nonnull default BiDoubleToLongFunction composeFromDouble(@Nonnull final DoubleFunction<? extends T> before1, @Nonnull final DoublePredicate before2) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); return (value1, value2) -> applyAsLong(before1.apply(value1), before2.test(value2)); }
From source file:at.gridtec.lambda4j.function.bi.obj.ObjBooleanToShortFunction.java
/** * Returns a composed {@link BiDoubleToShortFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. If evaluation of either operation throws an exception, it is * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to * execute an operation which accepts {@code double} input, before this primitive function is executed. * * @param before1 The first function to apply before this function is applied * @param before2 The second predicate to apply before this function is applied * @return A composed {@code BiDoubleToShortFunction} that first applies the {@code before} functions to its input, * and then applies this function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}.//from w ww . j a va 2 s . c o m */ @Nonnull default BiDoubleToShortFunction composeFromDouble(@Nonnull final DoubleFunction<? extends T> before1, @Nonnull final DoublePredicate before2) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); return (value1, value2) -> applyAsShort(before1.apply(value1), before2.test(value2)); }
From source file:at.gridtec.lambda4j.function.bi.obj.ObjBooleanToDoubleFunction.java
/** * Returns a composed {@link DoubleBinaryOperator2} that first applies the {@code before} functions to its input, * and then applies this function to the result. If evaluation of either operation throws an exception, it is * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to * execute an operation which accepts {@code double} input, before this primitive function is executed. * * @param before1 The first function to apply before this function is applied * @param before2 The second predicate to apply before this function is applied * @return A composed {@code DoubleBinaryOperator2} that first applies the {@code before} functions to its input, * and then applies this function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}.// ww w. j av a 2 s.c o m */ @Nonnull default DoubleBinaryOperator2 composeFromDouble(@Nonnull final DoubleFunction<? extends T> before1, @Nonnull final DoublePredicate before2) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); return (value1, value2) -> applyAsDouble(before1.apply(value1), before2.test(value2)); }
From source file:at.gridtec.lambda4j.function.tri.TriBooleanFunction.java
/** * Returns a composed {@link TriDoubleFunction} that first applies the {@code before} predicates to its input, and * then applies this function to the result. If evaluation of either operation throws an exception, it is relayed to * the caller of the composed operation. This method is just convenience, to provide the ability to execute an * operation which accepts {@code double} input, before this primitive function is executed. * * @param before1 The first predicate to apply before this function is applied * @param before2 The second predicate to apply before this function is applied * @param before3 The third predicate to apply before this function is applied * @return A composed {@code TriDoubleFunction} that first applies the {@code before} predicates to its input, and * then applies this function to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code * double}.// w ww . j av a 2 s . c o m */ @Nonnull default TriDoubleFunction<R> composeFromDouble(@Nonnull final DoublePredicate before1, @Nonnull final DoublePredicate before2, @Nonnull final DoublePredicate before3) { Objects.requireNonNull(before1); Objects.requireNonNull(before2); Objects.requireNonNull(before3); return (value1, value2, value3) -> apply(before1.test(value1), before2.test(value2), before3.test(value3)); }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjByteToDoubleFunction.java
/** * Returns a composed {@link BiObjBytePredicate} that first applies this function to its input, and then applies the * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to * the caller of the composed operation. This method is just convenience, to provide the ability to transform this * primitive function to an operation returning {@code boolean}. * * @param after The predicate to apply after this function is applied * @return A composed {@code BiObjBytePredicate} that first applies this function to its input, and then applies the * {@code after} predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}.//from www. j av a2 s .c o m */ @Nonnull default BiObjBytePredicate<T, U> andThenToBoolean(@Nonnull final DoublePredicate after) { Objects.requireNonNull(after); return (t, u, value) -> after.test(applyAsDouble(t, u, value)); }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjCharToDoubleFunction.java
/** * Returns a composed {@link BiObjCharPredicate} that first applies this function to its input, and then applies the * {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed to * the caller of the composed operation. This method is just convenience, to provide the ability to transform this * primitive function to an operation returning {@code boolean}. * * @param after The predicate to apply after this function is applied * @return A composed {@code BiObjCharPredicate} that first applies this function to its input, and then applies the * {@code after} predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}.// w w w . j av a 2 s. c om */ @Nonnull default BiObjCharPredicate<T, U> andThenToBoolean(@Nonnull final DoublePredicate after) { Objects.requireNonNull(after); return (t, u, value) -> after.test(applyAsDouble(t, u, value)); }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjFloatToDoubleFunction.java
/** * Returns a composed {@link BiObjFloatPredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed * to the caller of the composed operation. This method is just convenience, to provide the ability to transform * this primitive function to an operation returning {@code boolean}. * * @param after The predicate to apply after this function is applied * @return A composed {@code BiObjFloatPredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}./* w ww . j a va 2s . c om*/ */ @Nonnull default BiObjFloatPredicate<T, U> andThenToBoolean(@Nonnull final DoublePredicate after) { Objects.requireNonNull(after); return (t, u, value) -> after.test(applyAsDouble(t, u, value)); }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjShortToDoubleFunction.java
/** * Returns a composed {@link BiObjShortPredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed * to the caller of the composed operation. This method is just convenience, to provide the ability to transform * this primitive function to an operation returning {@code boolean}. * * @param after The predicate to apply after this function is applied * @return A composed {@code BiObjShortPredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}.//from w w w. ja v a 2 s . c o m */ @Nonnull default BiObjShortPredicate<T, U> andThenToBoolean(@Nonnull final DoublePredicate after) { Objects.requireNonNull(after); return (t, u, value) -> after.test(applyAsDouble(t, u, value)); }
From source file:at.gridtec.lambda4j.function.tri.obj.BiObjDoubleToDoubleFunction.java
/** * Returns a composed {@link BiObjDoublePredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. If evaluation of either operation throws an exception, it is relayed * to the caller of the composed operation. This method is just convenience, to provide the ability to transform * this primitive function to an operation returning {@code boolean}. * * @param after The predicate to apply after this function is applied * @return A composed {@code BiObjDoublePredicate} that first applies this function to its input, and then applies * the {@code after} predicate to the result. * @throws NullPointerException If given argument is {@code null} * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code * boolean}./*w ww.j a v a 2s . c o m*/ */ @Nonnull default BiObjDoublePredicate<T, U> andThenToBoolean(@Nonnull final DoublePredicate after) { Objects.requireNonNull(after); return (t, u, value) -> after.test(applyAsDouble(t, u, value)); }