eu.lunisolar.magma.func.function.conversion

Interface LFltToDblFunction

All Superinterfaces:

Codomain<aType.aDouble>, Domain, Domain1<aType.aFloat>, Formattable, MetaFunction, MetaFunctionalInterface, MetaInterface, MetaInterface.NonThrowing, MetaInterface.Throwing<RuntimeException>

All Known Implementing Classes:

LFltToDblFunction.LFltToDblFunctionSingle

@FunctionalInterface
public interface LFltToDblFunction
extends MetaFunction, MetaInterface.NonThrowing, Codomain<aType.aDouble>, Domain1<aType.aFloat>

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

Type: function

Domain (lvl: 1): float a

Co-domain: double

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	LFltToDblFunction.LFltToDblFunctionSingle

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
default double	applyAsDbl(float a)
default double	applyAsDbl(float a, ExWF<RuntimeException> exF)
default double	applyAsDbl(float a, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default double	applyAsDblThen(float a, LToDblFunction<Throwable> handler)
double	applyAsDblX(float a) Implement this, but call applyAsDbl(float a)
static double	call(float a, LFltToDblFunction lambda)
default LDblSupplier	capture(float a) Captures arguments but delays the evaluation.
default LFltToDblFunction	compose(LFltUnaryOperator before) Allows to manipulate the domain of the function.
static LFltToDblFunction	composed(LFltUnaryOperator before, LFltToDblFunction after)
static <V> LToDblFunction<V>	composed(LToFltFunction<? super V> before, LFltToDblFunction after)
static LFltToDblFunction	constant(double r) Creates function that always returns the same value.
static LFltToDblFunction	failSafe(LFltToDblFunction func, LFltToDblFunction failSafe)
default double	failSafeApplyAsDbl(float a, LFltToDblFunction failSafe)
static double	failSafeApplyAsDbl(float a, LFltToDblFunction func, LFltToDblFunction failSafe)
static LFltToDblFunction	fltToDblFunc(LFltToDblFunction lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
default <V> LToDblFunction<V>	fltToDblFuncCompose(LToFltFunction<? super V> before) Allows to manipulate the domain of the function.
static LFltToDblFunction	fltToDblFuncThrowing(ExF<Throwable> exF)
static LFltToDblFunction	fltToDblFuncThrowing(String message, ExMF<Throwable> exF)
default <C0> void	forEach(IndexedRead<C0,aType.aFloat> ia, C0 source, 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, float a, LFltToDblFunction func) From-To.
static void	fromTo(int min_i, int max_i, float a, LFltToDblFunction func) From-To.
default String	functionalInterfaceDescription() Returns description of the functional interface.
default LFltToDblFunction	handling(HandlingInstructions<Throwable,RuntimeException> handling)
default double	handlingApplyAsDbl(float a, HandlingInstructions<Throwable,RuntimeException> handling) Function call that handles exceptions according to the instructions.
static double	handlingApplyAsDbl(float a, LFltToDblFunction func, HandlingInstructions<Throwable,RuntimeException> handling)
default <C0,I0> void	iterate(SequentialRead<C0,I0,aType.aFloat> sa, C0 source, LDblConsumer consumer) For each element (or tuple) from arguments, calls the function and passes the result to consumer.
default double	nestingApplyAsDbl(float a) Function call that handles exceptions by always nesting checked exceptions and propagating the others as is.
default double	nonNullApplyAsDbl(float a) Just to mirror the method: Ensures the result is not null
static double	produceDouble(float a) Does nothing (LFltToDblFunction) Function
static LFltToDblFunction	recursive(LFunction<LFltToDblFunction,LFltToDblFunction> selfLambda)
static LFltToDblFunction	safe() Safe instance.
static LFltToDblFunction	safe(LFltToDblFunction other) Safe wrapping.
static LSupplier<LFltToDblFunction>	safeSupplier() Safe instance supplier.
static LSupplier<LFltToDblFunction>	safeSupplier(LSupplier<LFltToDblFunction> supplier) Safe supplier.
default double	shovingApplyAsDbl(float a) Function call that handles exceptions by always propagating them as is, even when they are undeclared checked ones.
default <V> LFltFunction<V>	then(LDblFunction<? extends V> after) Combines two functions together in a order.
default LFltPredicate	thenToBool(LDblPredicate after) Combines two functions together in a order.
default LFltToByteFunction	thenToByte(LDblToByteFunction after) Combines two functions together in a order.
default LFltToCharFunction	thenToChar(LDblToCharFunction after) Combines two functions together in a order.
default LFltToDblFunction	thenToDbl(LDblUnaryOperator after) Combines two functions together in a order.
default LFltUnaryOperator	thenToFlt(LDblToFltFunction after) Combines two functions together in a order.
default LFltToIntFunction	thenToInt(LDblToIntFunction after) Combines two functions together in a order.
default LFltToLongFunction	thenToLong(LDblToLongFunction after) Combines two functions together in a order.
default LFltToSrtFunction	thenToSrt(LDblToSrtFunction after) Combines two functions together in a order.
static void	times(int max_i, float a, LFltToDblFunction func) From-To.
static double	tryApplyAsDbl(float a, LFltToDblFunction func)
static double	tryApplyAsDbl(float a, LFltToDblFunction func, ExWF<RuntimeException> exF)
static double	tryApplyAsDbl(float a, LFltToDblFunction func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static double	tryApplyAsDblThen(float a, LFltToDblFunction func, LToDblFunction<Throwable> handler)
default LFltToDblFunction	trying(ExWF<RuntimeException> exF)
default LFltToDblFunction	trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LFltToDblFunction	tryingThen(LToDblFunction<Throwable> handler)
default double	tupleApplyAsDbl(LFltSingle args)

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, isOperator, isPredicate, isSupplier

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

applyAsDbl

default double applyAsDbl(float a)

applyAsDblX

double applyAsDblX(float a)
            throws Throwable

Implement this, but call applyAsDbl(float a)

Throws:

Throwable

tupleApplyAsDbl

default double tupleApplyAsDbl(LFltSingle args)

handlingApplyAsDbl

default double handlingApplyAsDbl(float a,
                                  HandlingInstructions<Throwable,RuntimeException> handling)

Function call that handles exceptions according to the instructions.

handling

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

applyAsDbl

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

trying

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

applyAsDbl

default double applyAsDbl(float a,
                          @Nonnull
                          ExWF<RuntimeException> exF)

trying

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

applyAsDblThen

default double applyAsDblThen(float a,
                              @Nonnull
                              LToDblFunction<Throwable> handler)

tryingThen

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

nestingApplyAsDbl

default double nestingApplyAsDbl(float a)

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

shovingApplyAsDbl

default double shovingApplyAsDbl(float a)

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

handlingApplyAsDbl

static double handlingApplyAsDbl(float a,
                                 LFltToDblFunction func,
                                 HandlingInstructions<Throwable,RuntimeException> handling)

tryApplyAsDbl

static double tryApplyAsDbl(float a,
                            LFltToDblFunction func)

tryApplyAsDbl

static double tryApplyAsDbl(float a,
                            LFltToDblFunction func,
                            @Nonnull
                            ExWMF<RuntimeException> exF,
                            @Nonnull
                            String newMessage,
                            @Nullable
                            Object... messageParams)

tryApplyAsDbl

static double tryApplyAsDbl(float a,
                            LFltToDblFunction func,
                            @Nonnull
                            ExWF<RuntimeException> exF)

tryApplyAsDblThen

static double tryApplyAsDblThen(float a,
                                LFltToDblFunction func,
                                @Nonnull
                                LToDblFunction<Throwable> handler)

failSafeApplyAsDbl

default double failSafeApplyAsDbl(float a,
                                  @Nonnull
                                  LFltToDblFunction failSafe)

failSafeApplyAsDbl

static double failSafeApplyAsDbl(float a,
                                 LFltToDblFunction func,
                                 @Nonnull
                                 LFltToDblFunction failSafe)

failSafe

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

nonNullApplyAsDbl

default double nonNullApplyAsDbl(float a)

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 a,
                   LFltToDblFunction func)

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

fromTill

static void fromTill(int min_i,
                     int max_i,
                     float a,
                     LFltToDblFunction func)

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

times

static void times(int max_i,
                  float a,
                  LFltToDblFunction func)

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

capture

default LDblSupplier capture(float a)

Captures arguments but delays the evaluation.

constant

static LFltToDblFunction constant(double r)

Creates function that always returns the same value.

fltToDblFunc

@Nonnull
static LFltToDblFunction fltToDblFunc(@Nonnull
                                                LFltToDblFunction lambda)

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

recursive

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

fltToDblFuncThrowing

@Nonnull
static LFltToDblFunction fltToDblFuncThrowing(@Nonnull
                                                        ExF<Throwable> exF)

fltToDblFuncThrowing

@Nonnull
static LFltToDblFunction fltToDblFuncThrowing(String message,
                                                        @Nonnull
                                                        ExMF<Throwable> exF)

call

static double call(float a,
                   @Nonnull
                   LFltToDblFunction lambda)

safe

@Nonnull
static LFltToDblFunction safe()

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

safeSupplier

@Nonnull
static LSupplier<LFltToDblFunction> safeSupplier()

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

safe

@Nonnull
static LFltToDblFunction safe(@Nullable
                                        LFltToDblFunction other)

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

safeSupplier

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

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

compose

@Nonnull
default LFltToDblFunction compose(@Nonnull
                                            LFltUnaryOperator before)

Allows to manipulate the domain of the function.

composed

static LFltToDblFunction composed(@Nonnull
                                  LFltUnaryOperator before,
                                  LFltToDblFunction after)

fltToDblFuncCompose

@Nonnull
default <V> LToDblFunction<V> fltToDblFuncCompose(@Nonnull
                                                            LToFltFunction<? super V> before)

Allows to manipulate the domain of the function.

composed

static <V> LToDblFunction<V> composed(@Nonnull
                                      LToFltFunction<? super V> before,
                                      LFltToDblFunction after)

then

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

Combines two functions together in a order.

thenToByte

@Nonnull
default LFltToByteFunction thenToByte(@Nonnull
                                                LDblToByteFunction after)

Combines two functions together in a order.

thenToSrt

@Nonnull
default LFltToSrtFunction thenToSrt(@Nonnull
                                              LDblToSrtFunction after)

Combines two functions together in a order.

thenToInt

@Nonnull
default LFltToIntFunction thenToInt(@Nonnull
                                              LDblToIntFunction after)

Combines two functions together in a order.

thenToLong

@Nonnull
default LFltToLongFunction thenToLong(@Nonnull
                                                LDblToLongFunction after)

Combines two functions together in a order.

thenToFlt

@Nonnull
default LFltUnaryOperator thenToFlt(@Nonnull
                                              LDblToFltFunction after)

Combines two functions together in a order.

thenToDbl

@Nonnull
default LFltToDblFunction thenToDbl(@Nonnull
                                              LDblUnaryOperator after)

Combines two functions together in a order.

thenToChar

@Nonnull
default LFltToCharFunction thenToChar(@Nonnull
                                                LDblToCharFunction after)

Combines two functions together in a order.

thenToBool

@Nonnull
default LFltPredicate thenToBool(@Nonnull
                                           LDblPredicate after)

Combines two functions together in a order.

produceDouble

static double produceDouble(float a)

Does nothing (LFltToDblFunction) Function

forEach

default <C0> void forEach(IndexedRead<C0,aType.aFloat> ia,
                          C0 source,
                          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 <C0,I0> void iterate(SequentialRead<C0,I0,aType.aFloat> sa,
                             C0 source,
                             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.