Uses of Interface
eu.lunisolar.magma.func.function.to.LToFltFunction

Packages that use LToFltFunction

Package	Description
eu.lunisolar.magma.func.consumer.primitives
eu.lunisolar.magma.func.consumer.primitives.bi
eu.lunisolar.magma.func.consumer.primitives.obj
eu.lunisolar.magma.func.function
eu.lunisolar.magma.func.function.conversion
eu.lunisolar.magma.func.function.from
eu.lunisolar.magma.func.function.to
eu.lunisolar.magma.func.operator.binary
eu.lunisolar.magma.func.operator.unary
eu.lunisolar.magma.func.predicate
eu.lunisolar.magma.func.supplier
eu.lunisolar.magma.func.tuple

Uses of LToFltFunction in eu.lunisolar.magma.func.consumer.primitives

Methods in eu.lunisolar.magma.func.consumer.primitives with parameters of type LToFltFunction

Modifier and Type	Method and Description
static <V> LConsumer<V>	LFltConsumer.composed(LToFltFunction<? super V> before, LFltConsumer after)
default <V> LConsumer<V>	LFltConsumer.fltConsCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.

Uses of LToFltFunction in eu.lunisolar.magma.func.consumer.primitives.bi

Methods in eu.lunisolar.magma.func.consumer.primitives.bi with parameters of type LToFltFunction

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.biFltConsCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.biFltConsCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiFltConsumer.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.composed(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2, LFltIntConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LFltIntConsumer.fltIntConsCompose(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.

Uses of LToFltFunction in eu.lunisolar.magma.func.consumer.primitives.obj

Methods in eu.lunisolar.magma.func.consumer.primitives.obj with parameters of type LToFltFunction

Modifier and Type	Method and Description
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.biObjFltConsCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiConsumer<V1,V2>	LObjFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltConsumer<T> after)
static <V1,V2,V3,T> LTriConsumer<V1,V2,V3>	LTieFltConsumer.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LTieFltConsumer<T> after)
static <V1,V2,V3,T1,T2> LTriConsumer<V1,V2,V3>	LBiObjFltConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltConsumer<T1,T2> after)
default <V1,V2> LBiConsumer<V1,V2>	LObjFltConsumer.objFltConsCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LConsumer<T>	LObjFltConsumer.rShrink(LToFltFunction<T> right)
static <T> LConsumer<T>	LObjFltConsumer.rShrinked(LToFltFunction<T> right, LObjFltConsumer<T> func)
default <V1,V2,V3> LTriConsumer<V1,V2,V3>	LTieFltConsumer.tieFltConsCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieFltConsumer.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToFltFunction<SRC> srcAcc3, LTieFltConsumer<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).

Uses of LToFltFunction in eu.lunisolar.magma.func.function

Methods in eu.lunisolar.magma.func.function that return LToFltFunction

Modifier and Type	Method and Description
default LToFltFunction<T>	LFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.function with parameters of type LToFltFunction

Modifier and Type	Method and Description
default LToFltFunction<T>	LFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LToFltBiFunction<T1,T2>	LBiFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.

Uses of LToFltFunction in eu.lunisolar.magma.func.function.conversion

Methods in eu.lunisolar.magma.func.function.conversion that return LToFltFunction

Modifier and Type	Method and Description
default <V> LToFltFunction<V>	LBoolToFltFunction.boolToFltFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LByteToFltFunction.byteToFltFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LCharToFltFunction.charToFltFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToFltFunction<V>	LBoolToFltFunction.composed(LPredicate<? super V> before, LBoolToFltFunction after)
static <V> LToFltFunction<V>	LByteToFltFunction.composed(LToByteFunction<? super V> before, LByteToFltFunction after)
static <V> LToFltFunction<V>	LCharToFltFunction.composed(LToCharFunction<? super V> before, LCharToFltFunction after)
static <V> LToFltFunction<V>	LDblToFltFunction.composed(LToDblFunction<? super V> before, LDblToFltFunction after)
static <V> LToFltFunction<V>	LIntToFltFunction.composed(LToIntFunction<? super V> before, LIntToFltFunction after)
static <V> LToFltFunction<V>	LLongToFltFunction.composed(LToLongFunction<? super V> before, LLongToFltFunction after)
static <V> LToFltFunction<V>	LSrtToFltFunction.composed(LToSrtFunction<? super V> before, LSrtToFltFunction after)
default <V> LToFltFunction<V>	LDblToFltFunction.dblToFltFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LIntToFltFunction.intToFltFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LLongToFltFunction.longToFltFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LSrtToFltFunction.srtToFltFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

Methods in eu.lunisolar.magma.func.function.conversion with parameters of type LToFltFunction

Modifier and Type	Method and Description
default float	LBoolToFltFunction.applyAsFltThen(boolean a, LToFltFunction<Throwable> handler)
default float	LByteToFltFunction.applyAsFltThen(byte a, LToFltFunction<Throwable> handler)
default float	LCharToFltFunction.applyAsFltThen(char a, LToFltFunction<Throwable> handler)
default float	LDblToFltFunction.applyAsFltThen(double a, LToFltFunction<Throwable> handler)
default float	LIntToFltFunction.applyAsFltThen(int a, LToFltFunction<Throwable> handler)
default float	LLongToFltFunction.applyAsFltThen(long a, LToFltFunction<Throwable> handler)
default float	LSrtToFltFunction.applyAsFltThen(short a, LToFltFunction<Throwable> handler)
static <V> LToByteFunction<V>	LFltToByteFunction.composed(LToFltFunction<? super V> before, LFltToByteFunction after)
static <V> LToCharFunction<V>	LFltToCharFunction.composed(LToFltFunction<? super V> before, LFltToCharFunction after)
static <V> LToDblFunction<V>	LFltToDblFunction.composed(LToFltFunction<? super V> before, LFltToDblFunction after)
static <V> LToIntFunction<V>	LFltToIntFunction.composed(LToFltFunction<? super V> before, LFltToIntFunction after)
static <V> LToLongFunction<V>	LFltToLongFunction.composed(LToFltFunction<? super V> before, LFltToLongFunction after)
static <V> LToSrtFunction<V>	LFltToSrtFunction.composed(LToFltFunction<? super V> before, LFltToSrtFunction after)
default <V> LToByteFunction<V>	LFltToByteFunction.fltToByteFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LFltToCharFunction.fltToCharFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LFltToDblFunction.fltToDblFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LFltToIntFunction.fltToIntFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LFltToLongFunction.fltToLongFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LFltToSrtFunction.fltToSrtFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
static float	LBoolToFltFunction.tryApplyAsFltThen(boolean a, LBoolToFltFunction func, LToFltFunction<Throwable> handler)
static float	LByteToFltFunction.tryApplyAsFltThen(byte a, LByteToFltFunction func, LToFltFunction<Throwable> handler)
static float	LCharToFltFunction.tryApplyAsFltThen(char a, LCharToFltFunction func, LToFltFunction<Throwable> handler)
static float	LDblToFltFunction.tryApplyAsFltThen(double a, LDblToFltFunction func, LToFltFunction<Throwable> handler)
static float	LIntToFltFunction.tryApplyAsFltThen(int a, LIntToFltFunction func, LToFltFunction<Throwable> handler)
static float	LLongToFltFunction.tryApplyAsFltThen(long a, LLongToFltFunction func, LToFltFunction<Throwable> handler)
static float	LSrtToFltFunction.tryApplyAsFltThen(short a, LSrtToFltFunction func, LToFltFunction<Throwable> handler)
default LSrtToFltFunction	LSrtToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LLongToFltFunction	LLongToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LIntToFltFunction	LIntToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LDblToFltFunction	LDblToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LCharToFltFunction	LCharToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LByteToFltFunction	LByteToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LBoolToFltFunction	LBoolToFltFunction.tryingThen(LToFltFunction<Throwable> handler)

Uses of LToFltFunction in eu.lunisolar.magma.func.function.from

Methods in eu.lunisolar.magma.func.function.from with parameters of type LToFltFunction

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiFltFunction.biFltFuncCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiFltFunction.biFltFuncCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.biObjFltFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjFltFunction.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjFltFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LFltFunction.composed(LToFltFunction<? super V> before, LFltFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiFltFunction.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiFltFunction.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltFunction<R> after)
default <V> LFunction<V,R>	LFltFunction.fltFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjFltFunction.objFltFuncCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntFltFunction.objIntFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjFltFunction.rShrink(LToFltFunction<T> right)
static <T,R> LFunction<T,R>	LObjFltFunction.rShrinked(LToFltFunction<T> right, LObjFltFunction<T,R> func)
default LSrtToFltFunction	LSrtFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LOiToFltFunction<T>	LOiFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LLongToFltFunction	LLongFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LIntToFltFunction	LIntFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LFltUnaryOperator	LFltFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LDblToFltFunction	LDblFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LCharToFltFunction	LCharFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LByteToFltFunction	LByteFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LBoolToFltFunction	LBoolFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.
default LFltBinaryOperator	LBiFltFunction.thenToFlt(LToFltFunction<? super R> after) Combines two functions together in a order.

Uses of LToFltFunction in eu.lunisolar.magma.func.function.to

Classes in eu.lunisolar.magma.func.function.to that implement LToFltFunction

Modifier and Type	Class and Description
static class	LToFltFunction.LToFltFunctionSingle<T>

Methods in eu.lunisolar.magma.func.function.to that return LToFltFunction

Modifier and Type	Method and Description
default <V2> LToFltFunction<V2>	LToFltFunction.cast() Cast that replace generics.
static <V2,T> LToFltFunction<V2>	LToFltFunction.cast(LToFltFunction<T> function) Cast that replace generics.
default <V> LToFltFunction<V>	LToFltFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
static <V,T> LToFltFunction<V>	LToFltFunction.composed(LFunction<? super V,? extends T> before, LToFltFunction<T> after)
static <T> LToFltFunction<T>	LToFltFunction.constant(float r) Creates function that always returns the same value.
static <T> LToFltFunction<T>	LToFltFunction.failSafe(LToFltFunction<T> func, LToFltFunction<T> failSafe)
default LToFltFunction<T>	LToFltFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LToFltFunction<T2>	LToFltBiFunction.lShrink(LFunction<T2,T1> left)
default LToFltFunction<T2>	LToFltBiFunction.lShrinkc(T1 a1)
static <T2,T1> LToFltFunction<T2>	LToFltBiFunction.lShrinked(LFunction<T2,T1> left, LToFltBiFunction<T1,T2> func)
static <T2,T1> LToFltFunction<T2>	LToFltBiFunction.lShrinkedc(T1 a1, LToFltBiFunction<T1,T2> func)
static <T> LToFltFunction<T>	LToFltFunction.recursive(LFunction<LToFltFunction<T>,LToFltFunction<T>> selfLambda)
default LToFltFunction<T1>	LToFltBiFunction.rShrink(LFunction<T1,T2> right)
default LToFltFunction<T>	LOiToFltFunction.rShrink(LToIntFunction<T> right)
default LToFltFunction<T>	LOiToFltFunction.rShrinkc(int a2)
default LToFltFunction<T1>	LToFltBiFunction.rShrinkc(T2 a2)
static <T1,T2> LToFltFunction<T1>	LToFltBiFunction.rShrinked(LFunction<T1,T2> right, LToFltBiFunction<T1,T2> func)
static <T> LToFltFunction<T>	LOiToFltFunction.rShrinked(LToIntFunction<T> right, LOiToFltFunction<T> func)
static <T> LToFltFunction<T>	LOiToFltFunction.rShrinkedc(int a2, LOiToFltFunction<T> func)
static <T1,T2> LToFltFunction<T1>	LToFltBiFunction.rShrinkedc(T2 a2, LToFltBiFunction<T1,T2> func)
static <T> LToFltFunction<T>	LToFltFunction.safe() Safe instance.
static <T> LToFltFunction<T>	LToFltFunction.safe(LToFltFunction<T> other) Safe wrapping.
default LToFltFunction<T>	LToByteFunction.thenToFlt(LByteToFltFunction after) Combines two functions together in a order.
default LToFltFunction<T>	LToCharFunction.thenToFlt(LCharToFltFunction after) Combines two functions together in a order.
default LToFltFunction<T>	LToDblFunction.thenToFlt(LDblToFltFunction after) Combines two functions together in a order.
default LToFltFunction<T>	LToFltFunction.thenToFlt(LFltUnaryOperator after) Combines two functions together in a order.
default LToFltFunction<T>	LToIntFunction.thenToFlt(LIntToFltFunction after) Combines two functions together in a order.
default LToFltFunction<T>	LToLongFunction.thenToFlt(LLongToFltFunction after) Combines two functions together in a order.
default LToFltFunction<T>	LToSrtFunction.thenToFlt(LSrtToFltFunction after) Combines two functions together in a order.
static <T> LToFltFunction<T>	LToFltFunction.toFltFunc(LToFltFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LToFltFunction<T>	LToFltFunction.toFltFuncThrowing(ExF<Throwable> exF)
static <T> LToFltFunction<T>	LToFltFunction.toFltFuncThrowing(String message, ExMF<Throwable> exF)
default LToFltFunction<T>	LToFltFunction.trying(ExWF<RuntimeException> exF)
default LToFltFunction<T>	LToFltFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToFltFunction<T>	LToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LToFltFunction	LToFltFunction.untyped() Cast that removes generics.
LToFltFunction<T>	LToFltFunction.LToFltFunctionSingle.value()

Methods in eu.lunisolar.magma.func.function.to that return types with arguments of type LToFltFunction

Modifier and Type	Method and Description
static <T> LSupplier<LToFltFunction<T>>	LToFltFunction.safeSupplier() Safe instance supplier.
static <T> LSupplier<LToFltFunction<T>>	LToFltFunction.safeSupplier(LSupplier<LToFltFunction<T>> supplier) Safe supplier.

Methods in eu.lunisolar.magma.func.function.to with parameters of type LToFltFunction

Modifier and Type	Method and Description
static <T> LOiToFltFunction<T>	LOiToFltFunction.apply1stAsFlt(LToFltFunction<T> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToFltBiFunction<T1,T2>	LToFltBiFunction.apply1stAsFlt(LToFltFunction<T1> func) Captures single parameter function into this interface where only 1st parameter will be used.
static <T1,T2> LToFltBiFunction<T1,T2>	LToFltBiFunction.apply2ndAsFlt(LToFltFunction<T2> func) Captures single parameter function into this interface where only 2nd parameter will be used.
default float	LToFltBiFunction.applyAsFltThen(T1 a1, T2 a2, LToFltFunction<Throwable> handler)
default float	LOiToFltFunction.applyAsFltThen(T a1, int a2, LToFltFunction<Throwable> handler)
default float	LToFltFunction.applyAsFltThen(T a, LToFltFunction<Throwable> handler)
static <T> float	LToFltFunction.call(T a, LToFltFunction<T> lambda)
static <V2,T> LToFltFunction<V2>	LToFltFunction.cast(LToFltFunction<T> function) Cast that replace generics.
static <V,T> LToFltFunction<V>	LToFltFunction.composed(LFunction<? super V,? extends T> before, LToFltFunction<T> after)
static <V1,V2,V3,T> LToIntTriFunction<V1,V2,V3>	LTieFltFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LTieFltFunction<T> after)
static <T> LToFltFunction<T>	LToFltFunction.failSafe(LToFltFunction<T> func, LToFltFunction<T> failSafe)
static <T> LToFltFunction<T>	LToFltFunction.failSafe(LToFltFunction<T> func, LToFltFunction<T> failSafe)
default float	LToFltFunction.failSafeApplyAsFlt(T a, LToFltFunction<T> failSafe)
static <T> float	LToFltFunction.failSafeApplyAsFlt(T a, LToFltFunction<T> func, LToFltFunction<T> failSafe)
static <T> float	LToFltFunction.failSafeApplyAsFlt(T a, LToFltFunction<T> func, LToFltFunction<T> failSafe)
static <T> void	LToFltFunction.fromTill(int min_i, int max_i, T a, LToFltFunction<T> func) From-To.
static <T> void	LToFltFunction.fromTo(int min_i, int max_i, T a, LToFltFunction<T> func) From-To.
static <T> float	LToFltFunction.handlingApplyAsFlt(T a, LToFltFunction<T> func, HandlingInstructions<Throwable,RuntimeException> handling)
static <T> LToFltFunction<T>	LToFltFunction.safe(LToFltFunction<T> other) Safe wrapping.
default <V1,V2,V3> LToIntTriFunction<V1,V2,V3>	LTieFltFunction.tieFltFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <T,SRC> int	LTieFltFunction.tieForEach(int sStart, int tStart, T trg1, SRC src3, LPredicate<SRC> srcTest3, LToFltFunction<SRC> srcAcc3, LTieFltFunction<? super T> consumer) For each element (or tuple) from arguments, calls the consumer (with TIE: ‘target’, index, element).
static <T> void	LToFltFunction.times(int max_i, T a, LToFltFunction<T> func) From-To.
static <T> LToFltFunction<T>	LToFltFunction.toFltFunc(LToFltFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> float	LToFltFunction.tryApplyAsFlt(T a, LToFltFunction<T> func)
static <T> float	LToFltFunction.tryApplyAsFlt(T a, LToFltFunction<T> func, ExWF<RuntimeException> exF)
static <T> float	LToFltFunction.tryApplyAsFlt(T a, LToFltFunction<T> func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static <T1,T2> float	LToFltBiFunction.tryApplyAsFltThen(T1 a1, T2 a2, LToFltBiFunction<T1,T2> func, LToFltFunction<Throwable> handler)
static <T> float	LOiToFltFunction.tryApplyAsFltThen(T a1, int a2, LOiToFltFunction<T> func, LToFltFunction<Throwable> handler)
static <T> float	LToFltFunction.tryApplyAsFltThen(T a, LToFltFunction<T> func, LToFltFunction<Throwable> handler)
static <T> float	LToFltFunction.tryApplyAsFltThen(T a, LToFltFunction<T> func, LToFltFunction<Throwable> handler)
default LToFltFunction<T>	LToFltFunction.tryingThen(LToFltFunction<Throwable> handler)
default LToFltBiFunction<T1,T2>	LToFltBiFunction.tryingThen(LToFltFunction<Throwable> handler)
default LOiToFltFunction<T>	LOiToFltFunction.tryingThen(LToFltFunction<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.function.to with type arguments of type LToFltFunction

Modifier and Type	Method and Description
static <T> LToFltFunction<T>	LToFltFunction.recursive(LFunction<LToFltFunction<T>,LToFltFunction<T>> selfLambda)
static <T> LToFltFunction<T>	LToFltFunction.recursive(LFunction<LToFltFunction<T>,LToFltFunction<T>> selfLambda)
static <T> LSupplier<LToFltFunction<T>>	LToFltFunction.safeSupplier(LSupplier<LToFltFunction<T>> supplier) Safe supplier.
static <T1,T2> LToFltBiFunction<T1,T2>	LToFltBiFunction.uncurry(LFunction<T1,LToFltFunction<T2>> func)

Uses of LToFltFunction in eu.lunisolar.magma.func.operator.binary

Methods in eu.lunisolar.magma.func.operator.binary with parameters of type LToFltFunction

Modifier and Type	Method and Description
default float	LFltBinaryOperator.applyAsFltThen(float a1, float a2, LToFltFunction<Throwable> handler)
static <V1,V2> LToFltBiFunction<V1,V2>	LFltBinaryOperator.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LFltBinaryOperator after)
static <V1,V2> LToFltBiFunction<V1,V2>	LFltBinaryOperator.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LFltBinaryOperator after)
default <V1,V2> LToFltBiFunction<V1,V2>	LFltBinaryOperator.fltBinaryOpCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToFltBiFunction<V1,V2>	LFltBinaryOperator.fltBinaryOpCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToFltBiFunction<T,T>	LBinaryOperator.thenToFlt(LToFltFunction<? super T> after) Combines two functions together in a order.
static float	LFltBinaryOperator.tryApplyAsFltThen(float a1, float a2, LFltBinaryOperator func, LToFltFunction<Throwable> handler)
default LFltBinaryOperator	LFltBinaryOperator.tryingThen(LToFltFunction<Throwable> handler)

Uses of LToFltFunction in eu.lunisolar.magma.func.operator.unary

Methods in eu.lunisolar.magma.func.operator.unary that return LToFltFunction

Modifier and Type	Method and Description
static <V> LToFltFunction<V>	LFltUnaryOperator.composed(LToFltFunction<? super V> before, LFltUnaryOperator after)
default <V> LToFltFunction<V>	LFltUnaryOperator.fltUnaryOpCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default LToFltFunction<T>	LUnaryOperator.thenToFlt(LToFltFunction<? super T> after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.operator.unary with parameters of type LToFltFunction

Modifier and Type	Method and Description
default float	LFltUnaryOperator.applyAsFltThen(float a, LToFltFunction<Throwable> handler)
static <V> LToFltFunction<V>	LFltUnaryOperator.composed(LToFltFunction<? super V> before, LFltUnaryOperator after)
default <V> LToFltFunction<V>	LFltUnaryOperator.fltUnaryOpCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default LToFltFunction<T>	LUnaryOperator.thenToFlt(LToFltFunction<? super T> after) Combines two functions together in a order.
static float	LFltUnaryOperator.tryApplyAsFltThen(float a, LFltUnaryOperator func, LToFltFunction<Throwable> handler)
default LFltUnaryOperator	LFltUnaryOperator.tryingThen(LToFltFunction<Throwable> handler)

Uses of LToFltFunction in eu.lunisolar.magma.func.predicate

Methods in eu.lunisolar.magma.func.predicate that return LToFltFunction

Modifier and Type	Method and Description
default LToFltFunction<T>	LPredicate.boolToToFltFunc(LBoolToFltFunction after) Combines two functions together in a order.

Methods in eu.lunisolar.magma.func.predicate with parameters of type LToFltFunction

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiFltPredicate.biFltPredCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiFltPredicate.biFltPredCompose(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.biObjFltPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiPredicate<V1,V2>	LObjFltPredicate.composed(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2, LObjFltPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3, LObjIntFltPredicate<T> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjFltPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToFltFunction<? super V3> before3, LBiObjFltPredicate<T1,T2> after)
static <V> LPredicate<V>	LFltPredicate.composed(LToFltFunction<? super V> before, LFltPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiFltPredicate.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiFltPredicate.composed(LToFltFunction<? super V1> before1, LToFltFunction<? super V2> before2, LBiFltPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LFltIntPredicate.composed(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2, LFltIntPredicate after)
default <V1,V2> LBiPredicate<V1,V2>	LFltIntPredicate.fltIntPredCompose(LToFltFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LFltPredicate.fltPredCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjFltPredicate.objFltPredCompose(LFunction<? super V1,? extends T> before1, LToFltFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntFltPredicate.objIntFltPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToFltFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LPredicate<T>	LObjFltPredicate.rShrink(LToFltFunction<T> right)
static <T> LPredicate<T>	LObjFltPredicate.rShrinked(LToFltFunction<T> right, LObjFltPredicate<T> func)

Uses of LToFltFunction in eu.lunisolar.magma.func.supplier

Methods in eu.lunisolar.magma.func.supplier with parameters of type LToFltFunction

Modifier and Type	Method and Description
default float	LFltSupplier.getAsFltThen(LToFltFunction<Throwable> handler)
default LFltSupplier	LSupplier.toFltSup(LToFltFunction<? super T> after) Combines two functions together in a order.
static float	LFltSupplier.tryGetAsFltThen(LFltSupplier func, LToFltFunction<Throwable> handler)
default LFltSupplier	LFltSupplier.tryingThen(LToFltFunction<Throwable> handler)

Uses of LToFltFunction in eu.lunisolar.magma.func.tuple

Methods in eu.lunisolar.magma.func.tuple with parameters of type LToFltFunction

Modifier and Type	Method and Description
<R> LFltPair.MutFltPair	LFltPair.MutFltPair.setFirstIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltPair.MutCompFltPair	LFltPair.MutCompFltPair.setFirstIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltIntPair.MutFltIntPair	LFltIntPair.MutFltIntPair.setFirstIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltIntPair.MutCompFltIntPair	LFltIntPair.MutCompFltIntPair.setFirstIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjFltPair.MutObjFltPair<T>	LObjFltPair.MutObjFltPair.setSecondIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjFltPair.MutCompObjFltPair<T>	LObjFltPair.MutCompObjFltPair.setSecondIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltPair.MutFltPair	LFltPair.MutFltPair.setSecondIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltPair.MutCompFltPair	LFltPair.MutCompFltPair.setSecondIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutObjIntFltTriple<T>	LObjIntFltTriple.MutObjIntFltTriple.setThirdIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntFltTriple.MutCompObjIntFltTriple<T>	LObjIntFltTriple.MutCompObjIntFltTriple.setThirdIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutBiObjFltTriple.setThirdIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjFltTriple.MutCompBiObjFltTriple<T1,T2>	LBiObjFltTriple.MutCompBiObjFltTriple.setThirdIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltSingle.MutFltSingle	LFltSingle.MutFltSingle.setValueIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LFltSingle.MutCompFltSingle	LFltSingle.MutCompFltSingle.setValueIfArgNotNull(R arg, LToFltFunction<R> func) Sets value derived from non-null argument, only if argument is not null.