eu.lunisolar.magma.func.operator.binary

Interface LDblBinaryOperator

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain2<aType.aDouble,aType.aDouble>, java.util.function.DoubleBinaryOperator, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LDblBinaryOperator.LDblBinaryOperatorSingle

@FunctionalInterface
public interface LDblBinaryOperator
extends java.util.function.DoubleBinaryOperator, MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain2<aType.aDouble,aType.aDouble>

Non-throwing functional interface (lambda) LDblBinaryOperator for Java 8.

Type: operator

Domain (lvl: 2): double a1,double a2

Co-domain: double

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LDblBinaryOperator.LDblBinaryOperatorSingle

Nested classes/interfaces inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

MetaInterface.NonThrowing, MetaInterface.Throwing<X>

Field Summary

Fields

Modifier and Type	Field and Description
static String	DESCRIPTION

Method Summary

Modifier and Type	Method and Description
static LDblBinaryOperator	apply1stAsDbl(LDblUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LDblBinaryOperator	apply2ndAsDbl(LDblUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default double	applyAsDbl(double a1, double a2)
default double	applyAsDbl(double a1, double a2, ExWF<RuntimeException> exF)
default double	applyAsDbl(double a1, double a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default double	applyAsDblThen(double a1, double a2, LToDblFunction<Throwable> handler)
double	applyAsDblX(double a1, double a2) Implement this, but call applyAsDbl(double a1,double a2)
default double	applyAsDouble(double a1, double a2) Deprecated. Calling this method via LDblBinaryOperator interface should be discouraged.
static double	call(double a1, double a2, LDblBinaryOperator lambda)
default LDblSupplier	capture(double a1, double a2) Captures arguments but delays the evaluation.
default LDblBinaryOperator	compose(LDblUnaryOperator before1, LDblUnaryOperator before2) Allows to manipulate the domain of the function.
static LDblBinaryOperator	composed(LDblUnaryOperator before1, LDblUnaryOperator before2, LDblBinaryOperator after)
static <V1,V2> LToDblBiFunction<V1,V2>	composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LDblBinaryOperator after)
static LDblBinaryOperator	constant(double r) Creates function that always returns the same value.
static LDblBinaryOperator	dblBinaryOp(LDblBinaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LToDblBiFunction<V1,V2>	dblBinaryOpCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LDblBinaryOperator	dblBinaryOpThrowing(ExF<Throwable> exF)
static LDblBinaryOperator	dblBinaryOpThrowing(String message, ExMF<Throwable> exF)
static LDblBinaryOperator	failSafe(LDblBinaryOperator func, LDblBinaryOperator failSafe)
default double	failSafeApplyAsDbl(double a1, double a2, LDblBinaryOperator failSafe)
static double	failSafeApplyAsDbl(double a1, double a2, LDblBinaryOperator func, LDblBinaryOperator failSafe)
default <C1,C2> void	forEach(IndexedRead<C1,aType.aDouble> ia1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
static void	fromTill(int min_i, int max_i, double a1, double a2, LDblBinaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, double a1, double a2, LDblBinaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LDblBinaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default double	handlingApplyAsDbl(double a1, double a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static double	handlingApplyAsDbl(double a1, double a2, LDblBinaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.aDouble> ia1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2> void	iterate(SequentialRead<C1,I1,aType.aDouble> sa1, C1 source1, IndexedRead<C2,aType.aDouble> ia2, C2 source2, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default <C1,I1,C2,I2> void	iterate(SequentialRead<C1,I1,aType.aDouble> sa1, C1 source1, SequentialRead<C2,I2,aType.aDouble> sa2, C2 source2, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LDblUnaryOperator	lShrink(LDblUnaryOperator left)
default LDblUnaryOperator	lShrinkc(double a1)
static LDblUnaryOperator	lShrinked(LDblUnaryOperator left, LDblBinaryOperator func)
static LDblUnaryOperator	lShrinkedc(double a1, LDblBinaryOperator func)
static LDblBinaryOperator	max() Returns function that returns the higher value.
static LDblBinaryOperator	maxBy(Comparator<Double> comparator) Creates function that returns the lesser value according to the comparator.
static LDblBinaryOperator	min() Returns function that returns the lower value.
static LDblBinaryOperator	minBy(Comparator<Double> comparator) Creates function that returns the lesser value according to the comparator.
default double	nestingApplyAsDbl(double a1, double a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default double	nonNullApplyAsDbl(double a1, double a2) Just to mirror the method: Ensures the result is not null
static double	produceDouble(double a1, double a2) Does nothing (LDblBinaryOperator) Operator
static LDblBinaryOperator	recursive(LFunction<LDblBinaryOperator,LDblBinaryOperator> selfLambda)
default LDblUnaryOperator	rShrink(LDblUnaryOperator right)
default LDblUnaryOperator	rShrinkc(double a2)
static LDblUnaryOperator	rShrinked(LDblUnaryOperator right, LDblBinaryOperator func)
static LDblUnaryOperator	rShrinkedc(double a2, LDblBinaryOperator func)
static LDblBinaryOperator	safe() Safe instance.
static LDblBinaryOperator	safe(LDblBinaryOperator other) Safe wrapping.
static LSupplier<LDblBinaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LDblBinaryOperator>	safeSupplier(LSupplier<LDblBinaryOperator> supplier) Safe supplier.
default double	shovingApplyAsDbl(double a1, double a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiDblFunction<V>	then(LDblFunction<? extends V> after) Combines two functions together in a order.
default LBiDblPredicate	thenToBool(LDblPredicate after) Combines two functions together in a order.
default LDblBinaryOperator	thenToDbl(LDblUnaryOperator after) Combines two functions together in a order.
static void	times(int max_i, double a1, double a2, LDblBinaryOperator func) From-To.
static double	tryApplyAsDbl(double a1, double a2, LDblBinaryOperator func)
static double	tryApplyAsDbl(double a1, double a2, LDblBinaryOperator func, ExWF<RuntimeException> exF)
static double	tryApplyAsDbl(double a1, double a2, LDblBinaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static double	tryApplyAsDblThen(double a1, double a2, LDblBinaryOperator func, LToDblFunction<Throwable> handler)
default LDblBinaryOperator	trying(ExWF<RuntimeException> exF)
default LDblBinaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LDblBinaryOperator	tryingThen(LToDblFunction<Throwable> handler)
default double	tupleApplyAsDbl(LDblPair args)
static LDblBinaryOperator	uncurry(LDblFunction<LDblUnaryOperator> func)
static LDblBinaryOperator	wrap(java.util.function.DoubleBinaryOperator other) Wraps JRE instance.

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaOperator

isOperator

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.type.MetaFunction

isFunction

Methods inherited from interface eu.lunisolar.magma.basics.meta.functional.MetaFunctionalInterface

formatTo, isAction, isConsumer, isPredicate, isSupplier

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface

isThrowing

Methods inherited from interface eu.lunisolar.magma.basics.meta.MetaInterface.NonThrowing

isThrowing

Field Detail

DESCRIPTION

static final String DESCRIPTION

See Also:

Constant Field Values

Method Detail

applyAsDouble

@Deprecated
default double applyAsDouble(double a1,
                                          double a2)

Deprecated. Calling this method via LDblBinaryOperator interface should be discouraged.

Default implementation for JRE method that calls exception nesting method.

Specified by:

applyAsDouble in interface java.util.function.DoubleBinaryOperator

applyAsDbl

default double applyAsDbl(double a1,
                          double a2)

applyAsDblX

double applyAsDblX(double a1,
                   double a2)
            throws Throwable

Implement this, but call applyAsDbl(double a1,double a2)

Throws:

Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LDblPair args)

handlingApplyAsDbl

default double handlingApplyAsDbl(double a1,
                                  double a2,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

default LDblBinaryOperator handling(HandlingInstructions<Throwable,RuntimeException> handling)

applyAsDbl

default double applyAsDbl(double a1,
                          double a2,
                          @Nonnull
                          ExWMF<RuntimeException> exF,
                          @Nonnull
                          String newMessage,
                          @Nullable
                          Object... messageParams)

trying

default LDblBinaryOperator trying(@Nonnull
                                  ExWMF<RuntimeException> exF,
                                  @Nonnull
                                  String newMessage,
                                  @Nullable
                                  Object... messageParams)

applyAsDbl

default double applyAsDbl(double a1,
                          double a2,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

default LDblBinaryOperator trying(@Nonnull
                                  ExWF<RuntimeException> exF)

applyAsDblThen

default double applyAsDblThen(double a1,
                              double a2,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

default LDblBinaryOperator tryingThen(@Nonnull
                                      LToDblFunction<Throwable> handler)

nestingApplyAsDbl

default double nestingApplyAsDbl(double a1,
                                 double a2)

Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.

shovingApplyAsDbl

default double shovingApplyAsDbl(double a1,
                                 double a2)

Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.

handlingApplyAsDbl

static double handlingApplyAsDbl(double a1,
                                 double a2,
                                 LDblBinaryOperator func,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static double tryApplyAsDbl(double a1,
                            double a2,
                            LDblBinaryOperator func)

tryApplyAsDbl

static double tryApplyAsDbl(double a1,
                            double a2,
                            LDblBinaryOperator func,
                            @Nonnull
                            ExWMF<RuntimeException> exF,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

tryApplyAsDbl

static double tryApplyAsDbl(double a1,
                            double a2,
                            LDblBinaryOperator func,
                            @Nonnull
                            ExWF<RuntimeException> exF)

tryApplyAsDblThen

static double tryApplyAsDblThen(double a1,
                                double a2,
                                LDblBinaryOperator func,
                                @Nonnull
                                LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(double a1,
                                  double a2,
                                  @Nonnull
                                  LDblBinaryOperator failSafe)

failSafeApplyAsDbl

static double failSafeApplyAsDbl(double a1,
                                 double a2,
                                 LDblBinaryOperator func,
                                 @Nonnull
                                 LDblBinaryOperator failSafe)

failSafe

static LDblBinaryOperator failSafe(LDblBinaryOperator func,
                                   @Nonnull
                                   LDblBinaryOperator failSafe)

nonNullApplyAsDbl

default double nonNullApplyAsDbl(double a1,
                                 double a2)

Just to mirror the method: Ensures the result is not null

functionalInterfaceDescription

@Nonnull
default String functionalInterfaceDescription()

Returns description of the functional interface.

Specified by:

functionalInterfaceDescription in interface MetaFunctionalInterface

fromTo

static void fromTo(int min_i,
                   int max_i,
                   double a1,
                   double a2,
                   LDblBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

fromTill

static void fromTill(int min_i,
                     int max_i,
                     double a1,
                     double a2,
                     LDblBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

times

static void times(int max_i,
                  double a1,
                  double a2,
                  LDblBinaryOperator func)

From-To. Intended to be used with non-capturing lambda.

lShrink

default LDblUnaryOperator lShrink(LDblUnaryOperator left)

lShrinkc

default LDblUnaryOperator lShrinkc(double a1)

lShrinked

static LDblUnaryOperator lShrinked(LDblUnaryOperator left,
                                   LDblBinaryOperator func)

lShrinkedc

static LDblUnaryOperator lShrinkedc(double a1,
                                    LDblBinaryOperator func)

rShrink

default LDblUnaryOperator rShrink(LDblUnaryOperator right)

rShrinkc

default LDblUnaryOperator rShrinkc(double a2)

rShrinked

static LDblUnaryOperator rShrinked(LDblUnaryOperator right,
                                   LDblBinaryOperator func)

rShrinkedc

static LDblUnaryOperator rShrinkedc(double a2,
                                    LDblBinaryOperator func)

uncurry

static LDblBinaryOperator uncurry(LDblFunction<LDblUnaryOperator> func)

capture

default LDblSupplier capture(double a1,
                             double a2)

Captures arguments but delays the evaluation.

constant

static LDblBinaryOperator constant(double r)

Creates function that always returns the same value.

apply1stAsDbl

@Nonnull
static LDblBinaryOperator apply1stAsDbl(@Nonnull
                                                  LDblUnaryOperator func)

Captures single parameter function into this interface where only 1st parameter will be used.

apply2ndAsDbl

@Nonnull
static LDblBinaryOperator apply2ndAsDbl(@Nonnull
                                                  LDblUnaryOperator func)

Captures single parameter function into this interface where only 2nd parameter will be used.

dblBinaryOp

@Nonnull
static LDblBinaryOperator dblBinaryOp(@Nonnull
                                                LDblBinaryOperator lambda)

Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).

recursive

@Nonnull
static LDblBinaryOperator recursive(@Nonnull
                                              LFunction<LDblBinaryOperator,LDblBinaryOperator> selfLambda)

dblBinaryOpThrowing

@Nonnull
static LDblBinaryOperator dblBinaryOpThrowing(@Nonnull
                                                        ExF<Throwable> exF)

dblBinaryOpThrowing

@Nonnull
static LDblBinaryOperator dblBinaryOpThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static double call(double a1,
                   double a2,
                   @Nonnull
                   LDblBinaryOperator lambda)

wrap

@Nonnull
static LDblBinaryOperator wrap(java.util.function.DoubleBinaryOperator other)

Wraps JRE instance.

safe

@Nonnull
static LDblBinaryOperator safe()

Safe instance. That always returns the same value (as produceDouble).

safeSupplier

@Nonnull
static LSupplier<LDblBinaryOperator> safeSupplier()

Safe instance supplier. Returns supplier of safe() instance.

safe

@Nonnull
static LDblBinaryOperator safe(@Nullable
                                         LDblBinaryOperator other)

Safe wrapping. Either argument function is returned (if it is not null) or safe() instance.

safeSupplier

@Nonnull
static LSupplier<LDblBinaryOperator> safeSupplier(@Nullable
                                                            LSupplier<LDblBinaryOperator> supplier)

Safe supplier. Either argument supplier is returned (if it is not null) or supplier of safe() instance.

minBy

@Nonnull
static LDblBinaryOperator minBy(@Nonnull
                                          Comparator<Double> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#minBy}

maxBy

@Nonnull
static LDblBinaryOperator maxBy(@Nonnull
                                          Comparator<Double> comparator)

Creates function that returns the lesser value according to the comparator.

See Also:

java.util.function.BinaryOperator#maxBy}

min

@Nonnull
static LDblBinaryOperator min()

Returns function that returns the lower value.

See Also:

java.util.function.BinaryOperator#minBy}

max

@Nonnull
static LDblBinaryOperator max()

Returns function that returns the higher value.

See Also:

java.util.function.BinaryOperator#maxBy}

compose

@Nonnull
default LDblBinaryOperator compose(@Nonnull
                                             LDblUnaryOperator before1,
                                             @Nonnull
                                             LDblUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LDblBinaryOperator composed(@Nonnull
                                   LDblUnaryOperator before1,
                                   @Nonnull
                                   LDblUnaryOperator before2,
                                   LDblBinaryOperator after)

dblBinaryOpCompose

@Nonnull
default <V1,V2> LToDblBiFunction<V1,V2> dblBinaryOpCompose(@Nonnull
                                                                     LToDblFunction<? super V1> before1,
                                                                     @Nonnull
                                                                     LToDblFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LToDblBiFunction<V1,V2> composed(@Nonnull
                                                LToDblFunction<? super V1> before1,
                                                @Nonnull
                                                LToDblFunction<? super V2> before2,
                                                LDblBinaryOperator after)

then

@Nonnull
default <V> LBiDblFunction<V> then(@Nonnull
                                             LDblFunction<? extends V> after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LDblBinaryOperator thenToDbl(@Nonnull
                                               LDblUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiDblPredicate thenToBool(@Nonnull
                                             LDblPredicate after)

Combines two functions together in a order.

produceDouble

static double produceDouble(double a1,
                            double a2)

Does nothing (LDblBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aDouble> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aDouble> ia2,
                             C2 source2,
                             LDblConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2> void iterate(SequentialRead<C1,I1,aType.aDouble> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aDouble> ia2,
                                C2 source2,
                                LDblConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,C2,I2> void iterate(IndexedRead<C1,aType.aDouble> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aDouble> sa2,
                                C2 source2,
                                LDblConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method is not expected.

iterate

default <C1,I1,C2,I2> void iterate(SequentialRead<C1,I1,aType.aDouble> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aDouble> sa2,
                                   C2 source2,
                                   LDblConsumer consumer)

For each element (or tuple) from arguments, calls the function and passes the result to consumer. Thread safety, fail-fast, fail-safety of this method depends highly on the arguments.