eu.lunisolar.magma.func.operator.binary

Interface LFltBinaryOperator

All Superinterfaces:

Codomain<aType.aFloat>, Domain, Domain2<aType.aFloat,aType.aFloat>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>, MetaOperator

All Known Implementing Classes:

LFltBinaryOperator.LFltBinaryOperatorSingle

@FunctionalInterface
public interface LFltBinaryOperator
extends MetaOperator, MetaInterface.NonThrowing, Codomain<aType.aFloat>, Domain2<aType.aFloat,aType.aFloat>

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

Type: operator

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

Co-domain: float

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LFltBinaryOperator.LFltBinaryOperatorSingle

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 LFltBinaryOperator	apply1stAsFlt(LFltUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LFltBinaryOperator	apply2ndAsFlt(LFltUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default float	applyAsFlt(float a1, float a2)
default float	applyAsFlt(float a1, float a2, ExWF<RuntimeException> exF)
default float	applyAsFlt(float a1, float a2, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default float	applyAsFltThen(float a1, float a2, LToFltFunction<Throwable> handler)
float	applyAsFltX(float a1, float a2) Implement this, but call applyAsFlt(float a1,float a2)
static float	call(float a1, float a2, LFltBinaryOperator lambda)
default LFltSupplier	capture(float a1, float a2) Captures arguments but delays the evaluation.
default LFltBinaryOperator	compose(LFltUnaryOperator before1, LFltUnaryOperator before2) Allows to manipulate the domain of the function.
static LFltBinaryOperator	composed(LFltUnaryOperator before1, LFltUnaryOperator before2, LFltBinaryOperator after)
static <V1,V2> LToFltBiFunction<V1,V2>	composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LFltBinaryOperator after)
static LFltBinaryOperator	constant(float r) Creates function that always returns the same value.
static LFltBinaryOperator	failSafe(LFltBinaryOperator func, LFltBinaryOperator failSafe)
default float	failSafeApplyAsFlt(float a1, float a2, LFltBinaryOperator failSafe)
static float	failSafeApplyAsFlt(float a1, float a2, LFltBinaryOperator func, LFltBinaryOperator failSafe)
static LFltBinaryOperator	fltBinaryOp(LFltBinaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V1,V2> LToFltBiFunction<V1,V2>	fltBinaryOpCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
static LFltBinaryOperator	fltBinaryOpThrowing(ExF<Throwable> exF)
static LFltBinaryOperator	fltBinaryOpThrowing(String message, ExMF<Throwable> exF)
default <C1,C2> void	forEach(IndexedRead<C1,aType.aFloat> ia1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LFltConsumer 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, float a1, float a2, LFltBinaryOperator func) From-To.
static void	fromTo(int min_i, int max_i, float a1, float a2, LFltBinaryOperator func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LFltBinaryOperator	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default float	handlingApplyAsFlt(float a1, float a2, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static float	handlingApplyAsFlt(float a1, float a2, LFltBinaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C1,C2,I2> void	iterate(IndexedRead<C1,aType.aFloat> ia1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LFltConsumer 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.aFloat> sa1, C1 source1, IndexedRead<C2,aType.aFloat> ia2, C2 source2, LFltConsumer 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.aFloat> sa1, C1 source1, SequentialRead<C2,I2,aType.aFloat> sa2, C2 source2, LFltConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default LFltUnaryOperator	lShrink(LFltUnaryOperator left)
default LFltUnaryOperator	lShrinkc(float a1)
static LFltUnaryOperator	lShrinked(LFltUnaryOperator left, LFltBinaryOperator func)
static LFltUnaryOperator	lShrinkedc(float a1, LFltBinaryOperator func)
static LFltBinaryOperator	max() Returns function that returns the higher value.
static LFltBinaryOperator	maxBy(Comparator<Float> comparator) Creates function that returns the lesser value according to the comparator.
static LFltBinaryOperator	min() Returns function that returns the lower value.
static LFltBinaryOperator	minBy(Comparator<Float> comparator) Creates function that returns the lesser value according to the comparator.
default float	nestingApplyAsFlt(float a1, float a2) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default float	nonNullApplyAsFlt(float a1, float a2) Just to mirror the method: Ensures the result is not null
static float	produceFloat(float a1, float a2) Does nothing (LFltBinaryOperator) Operator
static LFltBinaryOperator	recursive(LFunction<LFltBinaryOperator,LFltBinaryOperator> selfLambda)
default LFltUnaryOperator	rShrink(LFltUnaryOperator right)
default LFltUnaryOperator	rShrinkc(float a2)
static LFltUnaryOperator	rShrinked(LFltUnaryOperator right, LFltBinaryOperator func)
static LFltUnaryOperator	rShrinkedc(float a2, LFltBinaryOperator func)
static LFltBinaryOperator	safe() Safe instance.
static LFltBinaryOperator	safe(LFltBinaryOperator other) Safe wrapping.
static LSupplier<LFltBinaryOperator>	safeSupplier() Safe instance supplier.
static LSupplier<LFltBinaryOperator>	safeSupplier(LSupplier<LFltBinaryOperator> supplier) Safe supplier.
default float	shovingApplyAsFlt(float a1, float a2) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LBiFltFunction<V>	then(LFltFunction<? extends V> after) Combines two functions together in a order.
default LBiFltPredicate	thenToBool(LFltPredicate after) Combines two functions together in a order.
default LFltBinaryOperator	thenToFlt(LFltUnaryOperator after) Combines two functions together in a order.
static void	times(int max_i, float a1, float a2, LFltBinaryOperator func) From-To.
static float	tryApplyAsFlt(float a1, float a2, LFltBinaryOperator func)
static float	tryApplyAsFlt(float a1, float a2, LFltBinaryOperator func, ExWF<RuntimeException> exF)
static float	tryApplyAsFlt(float a1, float a2, LFltBinaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static float	tryApplyAsFltThen(float a1, float a2, LFltBinaryOperator func, LToFltFunction<Throwable> handler)
default LFltBinaryOperator	trying(ExWF<RuntimeException> exF)
default LFltBinaryOperator	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LFltBinaryOperator	tryingThen(LToFltFunction<Throwable> handler)
default float	tupleApplyAsFlt(LFltPair args)
static LFltBinaryOperator	uncurry(LFltFunction<LFltUnaryOperator> func)

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

applyAsFlt

default float applyAsFlt(float a1,
                         float a2)

applyAsFltX

float applyAsFltX(float a1,
                  float a2)
           throws Throwable

Implement this, but call applyAsFlt(float a1,float a2)

Throws:

Throwable

tupleApplyAsFlt

default float tupleApplyAsFlt(LFltPair args)

handlingApplyAsFlt

default float handlingApplyAsFlt(float a1,
                                 float a2,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsFlt

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

trying

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

applyAsFlt

default float applyAsFlt(float a1,
                         float a2,
                         @Nonnull
                         ExWF<RuntimeException> exF)

trying

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

applyAsFltThen

default float applyAsFltThen(float a1,
                             float a2,
                             @Nonnull
                             LToFltFunction<Throwable> handler)

tryingThen

default LFltBinaryOperator tryingThen(@Nonnull
                                      LToFltFunction<Throwable> handler)

nestingApplyAsFlt

default float nestingApplyAsFlt(float a1,
                                float a2)

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

shovingApplyAsFlt

default float shovingApplyAsFlt(float a1,
                                float a2)

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

handlingApplyAsFlt

static float handlingApplyAsFlt(float a1,
                                float a2,
                                LFltBinaryOperator func,
                                HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsFlt

static float tryApplyAsFlt(float a1,
                           float a2,
                           LFltBinaryOperator func)

tryApplyAsFlt

static float tryApplyAsFlt(float a1,
                           float a2,
                           LFltBinaryOperator func,
                           @Nonnull
                           ExWMF<RuntimeException> exF,
                           @Nonnull
                           String newMessage,
                           @Nullable
                           Object... messageParams)

tryApplyAsFlt

static float tryApplyAsFlt(float a1,
                           float a2,
                           LFltBinaryOperator func,
                           @Nonnull
                           ExWF<RuntimeException> exF)

tryApplyAsFltThen

static float tryApplyAsFltThen(float a1,
                               float a2,
                               LFltBinaryOperator func,
                               @Nonnull
                               LToFltFunction<Throwable> handler)

failSafeApplyAsFlt

default float failSafeApplyAsFlt(float a1,
                                 float a2,
                                 @Nonnull
                                 LFltBinaryOperator failSafe)

failSafeApplyAsFlt

static float failSafeApplyAsFlt(float a1,
                                float a2,
                                LFltBinaryOperator func,
                                @Nonnull
                                LFltBinaryOperator failSafe)

failSafe

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

nonNullApplyAsFlt

default float nonNullApplyAsFlt(float a1,
                                float 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,
                   float a1,
                   float a2,
                   LFltBinaryOperator func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     float a1,
                     float a2,
                     LFltBinaryOperator func)

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

times

static void times(int max_i,
                  float a1,
                  float a2,
                  LFltBinaryOperator func)

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

lShrink

default LFltUnaryOperator lShrink(LFltUnaryOperator left)

lShrinkc

default LFltUnaryOperator lShrinkc(float a1)

lShrinked

static LFltUnaryOperator lShrinked(LFltUnaryOperator left,
                                   LFltBinaryOperator func)

lShrinkedc

static LFltUnaryOperator lShrinkedc(float a1,
                                    LFltBinaryOperator func)

rShrink

default LFltUnaryOperator rShrink(LFltUnaryOperator right)

rShrinkc

default LFltUnaryOperator rShrinkc(float a2)

rShrinked

static LFltUnaryOperator rShrinked(LFltUnaryOperator right,
                                   LFltBinaryOperator func)

rShrinkedc

static LFltUnaryOperator rShrinkedc(float a2,
                                    LFltBinaryOperator func)

uncurry

static LFltBinaryOperator uncurry(LFltFunction<LFltUnaryOperator> func)

capture

default LFltSupplier capture(float a1,
                             float a2)

Captures arguments but delays the evaluation.

constant

static LFltBinaryOperator constant(float r)

Creates function that always returns the same value.

apply1stAsFlt

@Nonnull
static LFltBinaryOperator apply1stAsFlt(@Nonnull
                                                  LFltUnaryOperator func)

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

apply2ndAsFlt

@Nonnull
static LFltBinaryOperator apply2ndAsFlt(@Nonnull
                                                  LFltUnaryOperator func)

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

fltBinaryOp

@Nonnull
static LFltBinaryOperator fltBinaryOp(@Nonnull
                                                LFltBinaryOperator lambda)

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

recursive

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

fltBinaryOpThrowing

@Nonnull
static LFltBinaryOperator fltBinaryOpThrowing(@Nonnull
                                                        ExF<Throwable> exF)

fltBinaryOpThrowing

@Nonnull
static LFltBinaryOperator fltBinaryOpThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static float call(float a1,
                  float a2,
                  @Nonnull
                  LFltBinaryOperator lambda)

safe

@Nonnull
static LFltBinaryOperator safe()

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

safeSupplier

@Nonnull
static LSupplier<LFltBinaryOperator> safeSupplier()

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

safe

@Nonnull
static LFltBinaryOperator safe(@Nullable
                                         LFltBinaryOperator other)

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

safeSupplier

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

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

minBy

@Nonnull
static LFltBinaryOperator minBy(@Nonnull
                                          Comparator<Float> comparator)

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

See Also:

java.util.function.BinaryOperator#minBy}

maxBy

@Nonnull
static LFltBinaryOperator maxBy(@Nonnull
                                          Comparator<Float> comparator)

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

See Also:

java.util.function.BinaryOperator#maxBy}

min

@Nonnull
static LFltBinaryOperator min()

Returns function that returns the lower value.

See Also:

java.util.function.BinaryOperator#minBy}

max

@Nonnull
static LFltBinaryOperator max()

Returns function that returns the higher value.

See Also:

java.util.function.BinaryOperator#maxBy}

compose

@Nonnull
default LFltBinaryOperator compose(@Nonnull
                                             LFltUnaryOperator before1,
                                             @Nonnull
                                             LFltUnaryOperator before2)

Allows to manipulate the domain of the function.

composed

static LFltBinaryOperator composed(@Nonnull
                                   LFltUnaryOperator before1,
                                   @Nonnull
                                   LFltUnaryOperator before2,
                                   LFltBinaryOperator after)

fltBinaryOpCompose

@Nonnull
default <V1,V2> LToFltBiFunction<V1,V2> fltBinaryOpCompose(@Nonnull
                                                                     LToFltFunction<? super V1> before1,
                                                                     @Nonnull
                                                                     LToFltFunction<? super V2> before2)

Allows to manipulate the domain of the function.

composed

static <V1,V2> LToFltBiFunction<V1,V2> composed(@Nonnull
                                                LToFltFunction<? super V1> before1,
                                                @Nonnull
                                                LToFltFunction<? super V2> before2,
                                                LFltBinaryOperator after)

then

@Nonnull
default <V> LBiFltFunction<V> then(@Nonnull
                                             LFltFunction<? extends V> after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LFltBinaryOperator thenToFlt(@Nonnull
                                               LFltUnaryOperator after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LBiFltPredicate thenToBool(@Nonnull
                                             LFltPredicate after)

Combines two functions together in a order.

produceFloat

static float produceFloat(float a1,
                          float a2)

Does nothing (LFltBinaryOperator) Operator

forEach

default <C1,C2> void forEach(IndexedRead<C1,aType.aFloat> ia1,
                             C1 source1,
                             IndexedRead<C2,aType.aFloat> ia2,
                             C2 source2,
                             LFltConsumer 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.aFloat> sa1,
                                C1 source1,
                                IndexedRead<C2,aType.aFloat> ia2,
                                C2 source2,
                                LFltConsumer 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.aFloat> ia1,
                                C1 source1,
                                SequentialRead<C2,I2,aType.aFloat> sa2,
                                C2 source2,
                                LFltConsumer 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.aFloat> sa1,
                                   C1 source1,
                                   SequentialRead<C2,I2,aType.aFloat> sa2,
                                   C2 source2,
                                   LFltConsumer 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.