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

Packages that use LToDblFunction

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 LToDblFunction in eu.lunisolar.magma.func.consumer.primitives

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

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

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.biDblConsCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.biDblConsCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
static <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LBiDblConsumer.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblConsumer after)
static <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.composed(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2, LDblIntConsumer after)
default <V1,V2> LBiConsumer<V1,V2>	LDblIntConsumer.dblIntConsCompose(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.

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

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

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

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default <V> LToDblFunction<V>	LBoolToDblFunction.boolToDblFuncCompose(LPredicate<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LByteToDblFunction.byteToDblFuncCompose(LToByteFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LCharToDblFunction.charToDblFuncCompose(LToCharFunction<? super V> before) Allows to manipulate the domain of the function.
static <V> LToDblFunction<V>	LBoolToDblFunction.composed(LPredicate<? super V> before, LBoolToDblFunction after)
static <V> LToDblFunction<V>	LByteToDblFunction.composed(LToByteFunction<? super V> before, LByteToDblFunction after)
static <V> LToDblFunction<V>	LCharToDblFunction.composed(LToCharFunction<? super V> before, LCharToDblFunction after)
static <V> LToDblFunction<V>	LFltToDblFunction.composed(LToFltFunction<? super V> before, LFltToDblFunction after)
static <V> LToDblFunction<V>	LIntToDblFunction.composed(LToIntFunction<? super V> before, LIntToDblFunction after)
static <V> LToDblFunction<V>	LLongToDblFunction.composed(LToLongFunction<? super V> before, LLongToDblFunction after)
static <V> LToDblFunction<V>	LSrtToDblFunction.composed(LToSrtFunction<? super V> before, LSrtToDblFunction after)
default <V> LToDblFunction<V>	LFltToDblFunction.fltToDblFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LIntToDblFunction.intToDblFuncCompose(LToIntFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LLongToDblFunction.longToDblFuncCompose(LToLongFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToDblFunction<V>	LSrtToDblFunction.srtToDblFuncCompose(LToSrtFunction<? super V> before) Allows to manipulate the domain of the function.

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

Modifier and Type	Method and Description
default double	LBoolToDblFunction.applyAsDblThen(boolean a, LToDblFunction<Throwable> handler)
default double	LByteToDblFunction.applyAsDblThen(byte a, LToDblFunction<Throwable> handler)
default double	LCharToDblFunction.applyAsDblThen(char a, LToDblFunction<Throwable> handler)
default double	LFltToDblFunction.applyAsDblThen(float a, LToDblFunction<Throwable> handler)
default double	LIntToDblFunction.applyAsDblThen(int a, LToDblFunction<Throwable> handler)
default double	LLongToDblFunction.applyAsDblThen(long a, LToDblFunction<Throwable> handler)
default double	LSrtToDblFunction.applyAsDblThen(short a, LToDblFunction<Throwable> handler)
static <V> LToByteFunction<V>	LDblToByteFunction.composed(LToDblFunction<? super V> before, LDblToByteFunction after)
static <V> LToCharFunction<V>	LDblToCharFunction.composed(LToDblFunction<? super V> before, LDblToCharFunction after)
static <V> LToFltFunction<V>	LDblToFltFunction.composed(LToDblFunction<? super V> before, LDblToFltFunction after)
static <V> LToIntFunction<V>	LDblToIntFunction.composed(LToDblFunction<? super V> before, LDblToIntFunction after)
static <V> LToLongFunction<V>	LDblToLongFunction.composed(LToDblFunction<? super V> before, LDblToLongFunction after)
static <V> LToSrtFunction<V>	LDblToSrtFunction.composed(LToDblFunction<? super V> before, LDblToSrtFunction after)
default <V> LToByteFunction<V>	LDblToByteFunction.dblToByteFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToCharFunction<V>	LDblToCharFunction.dblToCharFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToFltFunction<V>	LDblToFltFunction.dblToFltFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToIntFunction<V>	LDblToIntFunction.dblToIntFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToLongFunction<V>	LDblToLongFunction.dblToLongFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V> LToSrtFunction<V>	LDblToSrtFunction.dblToSrtFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
static double	LBoolToDblFunction.tryApplyAsDblThen(boolean a, LBoolToDblFunction func, LToDblFunction<Throwable> handler)
static double	LByteToDblFunction.tryApplyAsDblThen(byte a, LByteToDblFunction func, LToDblFunction<Throwable> handler)
static double	LCharToDblFunction.tryApplyAsDblThen(char a, LCharToDblFunction func, LToDblFunction<Throwable> handler)
static double	LFltToDblFunction.tryApplyAsDblThen(float a, LFltToDblFunction func, LToDblFunction<Throwable> handler)
static double	LIntToDblFunction.tryApplyAsDblThen(int a, LIntToDblFunction func, LToDblFunction<Throwable> handler)
static double	LLongToDblFunction.tryApplyAsDblThen(long a, LLongToDblFunction func, LToDblFunction<Throwable> handler)
static double	LSrtToDblFunction.tryApplyAsDblThen(short a, LSrtToDblFunction func, LToDblFunction<Throwable> handler)
default LSrtToDblFunction	LSrtToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LLongToDblFunction	LLongToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LIntToDblFunction	LIntToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LFltToDblFunction	LFltToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LCharToDblFunction	LCharToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LByteToDblFunction	LByteToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LBoolToDblFunction	LBoolToDblFunction.tryingThen(LToDblFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default <V1,V2> LBiFunction<V1,V2,R>	LBiDblFunction.biDblFuncCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LBiDblFunction.biDblFuncCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.biObjDblFuncCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T,R> LBiFunction<V1,V2,R>	LObjDblFunction.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblFunction<T,R> after)
static <V1,V2,V3,T,R> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblFunction<T,R> after)
static <V1,V2,V3,T1,T2,R> LTriFunction<V1,V2,V3,R>	LBiObjDblFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblFunction<T1,T2,R> after)
static <V,R> LFunction<V,R>	LDblFunction.composed(LToDblFunction<? super V> before, LDblFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiDblFunction.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblFunction<R> after)
static <V1,V2,R> LBiFunction<V1,V2,R>	LBiDblFunction.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblFunction<R> after)
default <V> LFunction<V,R>	LDblFunction.dblFuncCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiFunction<V1,V2,R>	LObjDblFunction.objDblFuncCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriFunction<V1,V2,V3,R>	LObjIntDblFunction.objIntDblFuncCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LFunction<T,R>	LObjDblFunction.rShrink(LToDblFunction<T> right)
static <T,R> LFunction<T,R>	LObjDblFunction.rShrinked(LToDblFunction<T> right, LObjDblFunction<T,R> func)
default LSrtToDblFunction	LSrtFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LOiToDblFunction<T>	LOiFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LLongToDblFunction	LLongFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LIntToDblFunction	LIntFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LFltToDblFunction	LFltFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LDblUnaryOperator	LDblFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LCharToDblFunction	LCharFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LByteToDblFunction	LByteFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LBoolToDblFunction	LBoolFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.
default LDblBinaryOperator	LBiDblFunction.thenToDbl(LToDblFunction<? super R> after) Combines two functions together in a order.

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

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

Modifier and Type	Class and Description
static class	LToDblFunction.LToDblFunctionSingle<T>

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

Modifier and Type	Method and Description
default <V2> LToDblFunction<V2>	LToDblFunction.cast() Cast that replace generics.
static <V2,T> LToDblFunction<V2>	LToDblFunction.cast(LToDblFunction<T> function) Cast that replace generics.
default <V> LToDblFunction<V>	LToDblFunction.compose(LFunction<? super V,? extends T> before) Allows to manipulate the domain of the function.
static <V,T> LToDblFunction<V>	LToDblFunction.composed(LFunction<? super V,? extends T> before, LToDblFunction<T> after)
static <T> LToDblFunction<T>	LToDblFunction.constant(double r) Creates function that always returns the same value.
static <T> LToDblFunction<T>	LToDblFunction.failSafe(LToDblFunction<T> func, LToDblFunction<T> failSafe)
default LToDblFunction<T>	LToDblFunction.handling(HandlingInstructions<Throwable,RuntimeException> handling)
default LToDblFunction<T2>	LToDblBiFunction.lShrink(LFunction<T2,T1> left)
default LToDblFunction<T2>	LToDblBiFunction.lShrinkc(T1 a1)
static <T2,T1> LToDblFunction<T2>	LToDblBiFunction.lShrinked(LFunction<T2,T1> left, LToDblBiFunction<T1,T2> func)
static <T2,T1> LToDblFunction<T2>	LToDblBiFunction.lShrinkedc(T1 a1, LToDblBiFunction<T1,T2> func)
static <T> LToDblFunction<T>	LToDblFunction.recursive(LFunction<LToDblFunction<T>,LToDblFunction<T>> selfLambda)
default LToDblFunction<T1>	LToDblBiFunction.rShrink(LFunction<T1,T2> right)
default LToDblFunction<T>	LOiToDblFunction.rShrink(LToIntFunction<T> right)
default LToDblFunction<T>	LOiToDblFunction.rShrinkc(int a2)
default LToDblFunction<T1>	LToDblBiFunction.rShrinkc(T2 a2)
static <T1,T2> LToDblFunction<T1>	LToDblBiFunction.rShrinked(LFunction<T1,T2> right, LToDblBiFunction<T1,T2> func)
static <T> LToDblFunction<T>	LOiToDblFunction.rShrinked(LToIntFunction<T> right, LOiToDblFunction<T> func)
static <T> LToDblFunction<T>	LOiToDblFunction.rShrinkedc(int a2, LOiToDblFunction<T> func)
static <T1,T2> LToDblFunction<T1>	LToDblBiFunction.rShrinkedc(T2 a2, LToDblBiFunction<T1,T2> func)
static <T> LToDblFunction<T>	LToDblFunction.safe() Safe instance.
static <T> LToDblFunction<T>	LToDblFunction.safe(LToDblFunction<T> other) Safe wrapping.
default LToDblFunction<T>	LToByteFunction.thenToDbl(LByteToDblFunction after) Combines two functions together in a order.
default LToDblFunction<T>	LToCharFunction.thenToDbl(LCharToDblFunction after) Combines two functions together in a order.
default LToDblFunction<T>	LToDblFunction.thenToDbl(LDblUnaryOperator after) Combines two functions together in a order.
default LToDblFunction<T>	LToFltFunction.thenToDbl(LFltToDblFunction after) Combines two functions together in a order.
default LToDblFunction<T>	LToIntFunction.thenToDbl(LIntToDblFunction after) Combines two functions together in a order.
default LToDblFunction<T>	LToLongFunction.thenToDbl(LLongToDblFunction after) Combines two functions together in a order.
default LToDblFunction<T>	LToSrtFunction.thenToDbl(LSrtToDblFunction after) Combines two functions together in a order.
static <T> LToDblFunction<T>	LToDblFunction.toDblFunc(LToDblFunction<T> lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static <T> LToDblFunction<T>	LToDblFunction.toDblFuncThrowing(ExF<Throwable> exF)
static <T> LToDblFunction<T>	LToDblFunction.toDblFuncThrowing(String message, ExMF<Throwable> exF)
default LToDblFunction<T>	LToDblFunction.trying(ExWF<RuntimeException> exF)
default LToDblFunction<T>	LToDblFunction.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LToDblFunction<T>	LToDblFunction.tryingThen(LToDblFunction<Throwable> handler)
default LToDblFunction	LToDblFunction.untyped() Cast that removes generics.
LToDblFunction<T>	LToDblFunction.LToDblFunctionSingle.value()
static <T> LToDblFunction<T>	LToDblFunction.wrap(java.util.function.ToDoubleFunction<T> other) Wraps JRE instance.

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

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

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

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

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

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

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

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

Modifier and Type	Method and Description
default double	LDblBinaryOperator.applyAsDblThen(double a1, double a2, LToDblFunction<Throwable> handler)
static <V1,V2> LToDblBiFunction<V1,V2>	LDblBinaryOperator.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LDblBinaryOperator after)
static <V1,V2> LToDblBiFunction<V1,V2>	LDblBinaryOperator.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LDblBinaryOperator after)
default <V1,V2> LToDblBiFunction<V1,V2>	LDblBinaryOperator.dblBinaryOpCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LToDblBiFunction<V1,V2>	LDblBinaryOperator.dblBinaryOpCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default LToDblBiFunction<T,T>	LBinaryOperator.thenToDbl(LToDblFunction<? super T> after) Combines two functions together in a order.
static double	LDblBinaryOperator.tryApplyAsDblThen(double a1, double a2, LDblBinaryOperator func, LToDblFunction<Throwable> handler)
default LDblBinaryOperator	LDblBinaryOperator.tryingThen(LToDblFunction<Throwable> handler)

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

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

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

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

Modifier and Type	Method and Description
default double	LDblUnaryOperator.applyAsDblThen(double a, LToDblFunction<Throwable> handler)
static <V> LToDblFunction<V>	LDblUnaryOperator.composed(LToDblFunction<? super V> before, LDblUnaryOperator after)
default <V> LToDblFunction<V>	LDblUnaryOperator.dblUnaryOpCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default LToDblFunction<T>	LUnaryOperator.thenToDbl(LToDblFunction<? super T> after) Combines two functions together in a order.
static double	LDblUnaryOperator.tryApplyAsDblThen(double a, LDblUnaryOperator func, LToDblFunction<Throwable> handler)
default LDblUnaryOperator	LDblUnaryOperator.tryingThen(LToDblFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
default LToDblFunction<T>	LPredicate.boolToToDblFunc(LBoolToDblFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1,V2> LBiPredicate<V1,V2>	LBiDblPredicate.biDblPredCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LBiDblPredicate.biDblPredCompose(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.biObjDblPredCompose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
static <V1,V2,T> LBiPredicate<V1,V2>	LObjDblPredicate.composed(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2, LObjDblPredicate<T> after)
static <V1,V2,V3,T> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.composed(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3, LObjIntDblPredicate<T> after)
static <V1,V2,V3,T1,T2> LTriPredicate<V1,V2,V3>	LBiObjDblPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LToDblFunction<? super V3> before3, LBiObjDblPredicate<T1,T2> after)
static <V> LPredicate<V>	LDblPredicate.composed(LToDblFunction<? super V> before, LDblPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiDblPredicate.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LBiDblPredicate.composed(LToDblFunction<? super V1> before1, LToDblFunction<? super V2> before2, LBiDblPredicate after)
static <V1,V2> LBiPredicate<V1,V2>	LDblIntPredicate.composed(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2, LDblIntPredicate after)
default <V1,V2> LBiPredicate<V1,V2>	LDblIntPredicate.dblIntPredCompose(LToDblFunction<? super V1> before1, LToIntFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V> LPredicate<V>	LDblPredicate.dblPredCompose(LToDblFunction<? super V> before) Allows to manipulate the domain of the function.
default <V1,V2> LBiPredicate<V1,V2>	LObjDblPredicate.objDblPredCompose(LFunction<? super V1,? extends T> before1, LToDblFunction<? super V2> before2) Allows to manipulate the domain of the function.
default <V1,V2,V3> LTriPredicate<V1,V2,V3>	LObjIntDblPredicate.objIntDblPredCompose(LFunction<? super V1,? extends T> before1, LToIntFunction<? super V2> before2, LToDblFunction<? super V3> before3) Allows to manipulate the domain of the function.
default LPredicate<T>	LObjDblPredicate.rShrink(LToDblFunction<T> right)
static <T> LPredicate<T>	LObjDblPredicate.rShrinked(LToDblFunction<T> right, LObjDblPredicate<T> func)

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

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

Modifier and Type	Method and Description
default double	LDblSupplier.getAsDblThen(LToDblFunction<Throwable> handler)
default LDblSupplier	LSupplier.toDblSup(LToDblFunction<? super T> after) Combines two functions together in a order.
static double	LDblSupplier.tryGetAsDblThen(LDblSupplier func, LToDblFunction<Throwable> handler)
default LDblSupplier	LDblSupplier.tryingThen(LToDblFunction<Throwable> handler)

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

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

Modifier and Type	Method and Description
<R> LDblPair.MutDblPair	LDblPair.MutDblPair.setFirstIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblPair.MutCompDblPair	LDblPair.MutCompDblPair.setFirstIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblIntPair.MutDblIntPair	LDblIntPair.MutDblIntPair.setFirstIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblIntPair.MutCompDblIntPair	LDblIntPair.MutCompDblIntPair.setFirstIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjDblPair.MutObjDblPair<T>	LObjDblPair.MutObjDblPair.setSecondIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjDblPair.MutCompObjDblPair<T>	LObjDblPair.MutCompObjDblPair.setSecondIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblPair.MutDblPair	LDblPair.MutDblPair.setSecondIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblPair.MutCompDblPair	LDblPair.MutCompDblPair.setSecondIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutObjIntDblTriple<T>	LObjIntDblTriple.MutObjIntDblTriple.setThirdIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LObjIntDblTriple.MutCompObjIntDblTriple<T>	LObjIntDblTriple.MutCompObjIntDblTriple.setThirdIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutBiObjDblTriple.setThirdIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LBiObjDblTriple.MutCompBiObjDblTriple<T1,T2>	LBiObjDblTriple.MutCompBiObjDblTriple.setThirdIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblSingle.MutDblSingle	LDblSingle.MutDblSingle.setValueIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.
<R> LDblSingle.MutCompDblSingle	LDblSingle.MutCompDblSingle.setValueIfArgNotNull(R arg, LToDblFunction<R> func) Sets value derived from non-null argument, only if argument is not null.