Uses of Interface
eu.lunisolar.magma.func.operator.unary.LIntUnaryOperator

Packages that use LIntUnaryOperator

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.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

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

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

Modifier and Type	Method and Description
default LIntConsumer	LIntConsumer.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntConsumer	LIntConsumer.composed(LIntUnaryOperator before, LIntConsumer after)

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

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

Modifier and Type	Method and Description
default LByteIntConsumer	LByteIntConsumer.compose(LByteUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LCharIntConsumer	LCharIntConsumer.compose(LCharUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LDblIntConsumer	LDblIntConsumer.compose(LDblUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LFltIntConsumer	LFltIntConsumer.compose(LFltUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LBiIntConsumer	LBiIntConsumer.compose(LIntUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LBoolIntConsumer	LBoolIntConsumer.compose(LLogicalOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LLongIntConsumer	LLongIntConsumer.compose(LLongUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LSrtIntConsumer	LSrtIntConsumer.compose(LSrtUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static LByteIntConsumer	LByteIntConsumer.composed(LByteUnaryOperator before1, LIntUnaryOperator before2, LByteIntConsumer after)
static LCharIntConsumer	LCharIntConsumer.composed(LCharUnaryOperator before1, LIntUnaryOperator before2, LCharIntConsumer after)
static LDblIntConsumer	LDblIntConsumer.composed(LDblUnaryOperator before1, LIntUnaryOperator before2, LDblIntConsumer after)
static LFltIntConsumer	LFltIntConsumer.composed(LFltUnaryOperator before1, LIntUnaryOperator before2, LFltIntConsumer after)
static LBiIntConsumer	LBiIntConsumer.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LBiIntConsumer after)
static LBoolIntConsumer	LBoolIntConsumer.composed(LLogicalOperator before1, LIntUnaryOperator before2, LBoolIntConsumer after)
static LLongIntConsumer	LLongIntConsumer.composed(LLongUnaryOperator before1, LIntUnaryOperator before2, LLongIntConsumer after)
static LSrtIntConsumer	LSrtIntConsumer.composed(LSrtUnaryOperator before1, LIntUnaryOperator before2, LSrtIntConsumer after)
default LIntConsumer	LBiIntConsumer.lShrink(LIntUnaryOperator left)
static LIntConsumer	LBiIntConsumer.lShrinked(LIntUnaryOperator left, LBiIntConsumer func)
default LIntConsumer	LBiIntConsumer.rShrink(LIntUnaryOperator right)
static LIntConsumer	LBiIntConsumer.rShrinked(LIntUnaryOperator right, LBiIntConsumer func)

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

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

Modifier and Type	Method and Description
default <V1> LObjIntConsumer<V1>	LObjIntConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LTieByteConsumer<V1>	LTieByteConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieCharConsumer<V1>	LTieCharConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieDblConsumer<V1>	LTieDblConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieFltConsumer<V1>	LTieFltConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieIntConsumer<V1>	LTieIntConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieBoolConsumer<V1>	LTieBoolConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieLongConsumer<V1>	LTieLongConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieSrtConsumer<V1>	LTieSrtConsumer.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieConsumer<V1,V3>	LTieConsumer.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V1,T> LTieByteConsumer<V1>	LTieByteConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LTieByteConsumer<T> after)
static <V1,T> LTieCharConsumer<V1>	LTieCharConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LTieCharConsumer<T> after)
static <V1,T> LTieDblConsumer<V1>	LTieDblConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LTieDblConsumer<T> after)
static <V1,T> LTieFltConsumer<V1>	LTieFltConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LTieFltConsumer<T> after)
static <V1,T> LTieIntConsumer<V1>	LTieIntConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LTieIntConsumer<T> after)
static <V1,T> LTieBoolConsumer<V1>	LTieBoolConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LTieBoolConsumer<T> after)
static <V1,T> LTieLongConsumer<V1>	LTieLongConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LTieLongConsumer<T> after)
static <V1,T> LObjIntConsumer<V1>	LObjIntConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntConsumer<T> after)
static <V1,T> LTieSrtConsumer<V1>	LTieSrtConsumer.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LTieSrtConsumer<T> after)
static <V1,V2,T1,T2> LBiObjIntConsumer<V1,V2>	LBiObjIntConsumer.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntConsumer<T1,T2> after)
static <V1,V3,T1,T2> LTieConsumer<V1,V3>	LTieConsumer.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieConsumer<T1,T2> after)

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

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

Modifier and Type	Method and Description
default LIntUnaryOperator	LIntToByteFunction.thenToInt(LByteToIntFunction after) Combines two functions together in a order.
default LIntUnaryOperator	LIntToCharFunction.thenToInt(LCharToIntFunction after) Combines two functions together in a order.
default LIntUnaryOperator	LIntToDblFunction.thenToInt(LDblToIntFunction after) Combines two functions together in a order.
default LIntUnaryOperator	LIntToFltFunction.thenToInt(LFltToIntFunction after) Combines two functions together in a order.
default LIntUnaryOperator	LIntToLongFunction.thenToInt(LLongToIntFunction after) Combines two functions together in a order.
default LIntUnaryOperator	LIntToSrtFunction.thenToInt(LSrtToIntFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LIntToSrtFunction	LIntToSrtFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LIntToLongFunction	LIntToLongFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LIntToFltFunction	LIntToFltFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LIntToDblFunction	LIntToDblFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LIntToCharFunction	LIntToCharFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LIntToByteFunction	LIntToByteFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntToByteFunction	LIntToByteFunction.composed(LIntUnaryOperator before, LIntToByteFunction after)
static LIntToCharFunction	LIntToCharFunction.composed(LIntUnaryOperator before, LIntToCharFunction after)
static LIntToDblFunction	LIntToDblFunction.composed(LIntUnaryOperator before, LIntToDblFunction after)
static LIntToFltFunction	LIntToFltFunction.composed(LIntUnaryOperator before, LIntToFltFunction after)
static LIntToLongFunction	LIntToLongFunction.composed(LIntUnaryOperator before, LIntToLongFunction after)
static LIntToSrtFunction	LIntToSrtFunction.composed(LIntUnaryOperator before, LIntToSrtFunction after)
default LSrtToIntFunction	LSrtToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LLongToIntFunction	LLongToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LFltToIntFunction	LFltToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LDblToIntFunction	LDblToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LCharToIntFunction	LCharToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LByteToIntFunction	LByteToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LBoolToIntFunction	LBoolToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.

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

Methods in eu.lunisolar.magma.func.function.from that return LIntUnaryOperator

Modifier and Type	Method and Description
default LIntUnaryOperator	LIntFunction.thenToInt(LToIntFunction<? super R> after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default <V1> LOiFunction<V1,R>	LOiFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntByteFunction<V1,R>	LObjIntByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntCharFunction<V1,R>	LObjIntCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntDblFunction<V1,R>	LObjIntDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntFltFunction<V1,R>	LObjIntFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBiIntFunction<V1,R>	LObjBiIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntBoolFunction<V1,R>	LObjIntBoolFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntLongFunction<V1,R>	LObjIntLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntSrtFunction<V1,R>	LObjIntSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default LIntFunction<R>	LIntFunction.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LBiIntFunction<R>	LBiIntFunction.compose(LIntUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static <V1,T,R> LObjIntByteFunction<V1,R>	LObjIntByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LObjIntByteFunction<T,R> after)
static <V1,T,R> LObjIntCharFunction<V1,R>	LObjIntCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LObjIntCharFunction<T,R> after)
static <V1,T,R> LObjIntDblFunction<V1,R>	LObjIntDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LObjIntDblFunction<T,R> after)
static <V1,T,R> LObjIntFltFunction<V1,R>	LObjIntFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LObjIntFltFunction<T,R> after)
static <V1,T,R> LObjBiIntFunction<V1,R>	LObjBiIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LObjBiIntFunction<T,R> after)
static <V1,T,R> LObjIntBoolFunction<V1,R>	LObjIntBoolFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LObjIntBoolFunction<T,R> after)
static <V1,T,R> LObjIntLongFunction<V1,R>	LObjIntLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LObjIntLongFunction<T,R> after)
static <V1,T,R> LOiFunction<V1,R>	LOiFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiFunction<T,R> after)
static <V1,T,R> LObjIntSrtFunction<V1,R>	LObjIntSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LObjIntSrtFunction<T,R> after)
static <V1,V2,T1,T2,R> LBiObjIntFunction<V1,V2,R>	LBiObjIntFunction.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntFunction<T1,T2,R> after)
static <V1,V3,T1,T2,R> LObjIntObjFunction<V1,V3,R>	LObjIntObjFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjFunction<T1,T2,R> after)
static <R> LIntFunction<R>	LIntFunction.composed(LIntUnaryOperator before, LIntFunction<R> after)
static <R> LBiIntFunction<R>	LBiIntFunction.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LBiIntFunction<R> after)
default LIntFunction<R>	LBiIntFunction.lShrink(LIntUnaryOperator left)
static <R> LIntFunction<R>	LBiIntFunction.lShrinked(LIntUnaryOperator left, LBiIntFunction<R> func)
default LIntFunction<R>	LBiIntFunction.rShrink(LIntUnaryOperator right)
static <R> LIntFunction<R>	LBiIntFunction.rShrinked(LIntUnaryOperator right, LBiIntFunction<R> func)

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

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

Modifier and Type	Method and Description
default LIntUnaryOperator	LOiToIntFunction.lShrink(LIntFunction<T> left)
default LIntUnaryOperator	LOiToIntFunction.lShrinkc(T a1)
static <T> LIntUnaryOperator	LOiToIntFunction.lShrinked(LIntFunction<T> left, LOiToIntFunction<T> func)
static <T> LIntUnaryOperator	LOiToIntFunction.lShrinkedc(T a1, LOiToIntFunction<T> func)

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

Modifier and Type	Method and Description
static <T> LTieSrtFunction<T>	LTieSrtFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieLongFunction<T>	LTieLongFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieIntFunction<T>	LTieIntFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieFltFunction<T>	LTieFltFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieDblFunction<T>	LTieDblFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieCharFunction<T>	LTieCharFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieByteFunction<T>	LTieByteFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieBoolFunction<T>	LTieBoolFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LOiToIntFunction<T>	LOiToIntFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T1,T2> LTieFunction<T1,T2>	LTieFunction.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
static <T> LTieIntFunction<T>	LTieIntFunction.apply3rdAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 3rd parameter will be used.
default <V1> LOiToSrtFunction<V1>	LOiToSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToLongFunction<V1>	LOiToLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToIntFunction<V1>	LOiToIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToFltFunction<V1>	LOiToFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToDblFunction<V1>	LOiToDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToCharFunction<V1>	LOiToCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LOiToByteFunction<V1>	LOiToByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LTieByteFunction<V1>	LTieByteFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieCharFunction<V1>	LTieCharFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieDblFunction<V1>	LTieDblFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieFltFunction<V1>	LTieFltFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieIntFunction<V1>	LTieIntFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieBoolFunction<V1>	LTieBoolFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieLongFunction<V1>	LTieLongFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LTieSrtFunction<V1>	LTieSrtFunction.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LTieFunction<V1,V3>	LTieFunction.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
static <V1,T> LTieByteFunction<V1>	LTieByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LTieByteFunction<T> after)
static <V1,T> LTieCharFunction<V1>	LTieCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LTieCharFunction<T> after)
static <V1,T> LTieDblFunction<V1>	LTieDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LTieDblFunction<T> after)
static <V1,T> LTieFltFunction<V1>	LTieFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LTieFltFunction<T> after)
static <V1,T> LTieIntFunction<V1>	LTieIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LTieIntFunction<T> after)
static <V1,T> LTieBoolFunction<V1>	LTieBoolFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LTieBoolFunction<T> after)
static <V1,T> LTieLongFunction<V1>	LTieLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LTieLongFunction<T> after)
static <V1,T> LOiToByteFunction<V1>	LOiToByteFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToByteFunction<T> after)
static <V1,T> LOiToCharFunction<V1>	LOiToCharFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToCharFunction<T> after)
static <V1,T> LOiToDblFunction<V1>	LOiToDblFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToDblFunction<T> after)
static <V1,T> LOiToFltFunction<V1>	LOiToFltFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToFltFunction<T> after)
static <V1,T> LOiToIntFunction<V1>	LOiToIntFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToIntFunction<T> after)
static <V1,T> LOiToLongFunction<V1>	LOiToLongFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToLongFunction<T> after)
static <V1,T> LOiToSrtFunction<V1>	LOiToSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LOiToSrtFunction<T> after)
static <V1,T> LTieSrtFunction<V1>	LTieSrtFunction.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LTieSrtFunction<T> after)
static <V1,V3,T1,T2> LTieFunction<V1,V3>	LTieFunction.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LTieFunction<T1,T2> after)
default LToIntTriFunction<T1,T2,T3>	LToIntTriFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LToIntFunction<T>	LToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LToIntBiFunction<T1,T2>	LToIntBiFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieSrtFunction<T>	LTieSrtFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieLongFunction<T>	LTieLongFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieIntFunction<T>	LTieIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieFunction<T1,T2>	LTieFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieFltFunction<T>	LTieFltFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieDblFunction<T>	LTieDblFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieCharFunction<T>	LTieCharFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieByteFunction<T>	LTieByteFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LTieBoolFunction<T>	LTieBoolFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LOiToIntFunction<T>	LOiToIntFunction.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
static <T> LTieIntFunction<T>	LTieIntFunction.uncurry(LFunction<T,LIntFunction<LIntUnaryOperator>> func)
static <T> LOiToIntFunction<T>	LOiToIntFunction.uncurry(LFunction<T,LIntUnaryOperator> func)

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

Methods in eu.lunisolar.magma.func.operator.binary that return LIntUnaryOperator

Modifier and Type	Method and Description
default LIntUnaryOperator	LIntBinaryOperator.lShrink(LIntUnaryOperator left)
default LIntUnaryOperator	LIntBinaryOperator.lShrinkc(int a1)
static LIntUnaryOperator	LIntBinaryOperator.lShrinked(LIntUnaryOperator left, LIntBinaryOperator func)
static LIntUnaryOperator	LIntBinaryOperator.lShrinkedc(int a1, LIntBinaryOperator func)
default LIntUnaryOperator	LIntBinaryOperator.rShrink(LIntUnaryOperator right)
default LIntUnaryOperator	LIntBinaryOperator.rShrinkc(int a2)
static LIntUnaryOperator	LIntBinaryOperator.rShrinked(LIntUnaryOperator right, LIntBinaryOperator func)
static LIntUnaryOperator	LIntBinaryOperator.rShrinkedc(int a2, LIntBinaryOperator func)

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

Modifier and Type	Method and Description
static LIntBinaryOperator	LIntBinaryOperator.apply1stAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 1st parameter will be used.
static LIntBinaryOperator	LIntBinaryOperator.apply2ndAsInt(LIntUnaryOperator func) Captures single parameter function into this interface where only 2nd parameter will be used.
default LIntBinaryOperator	LIntBinaryOperator.compose(LIntUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static LIntBinaryOperator	LIntBinaryOperator.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LIntBinaryOperator after)
default LIntUnaryOperator	LIntBinaryOperator.lShrink(LIntUnaryOperator left)
static LIntUnaryOperator	LIntBinaryOperator.lShrinked(LIntUnaryOperator left, LIntBinaryOperator func)
default LIntUnaryOperator	LIntBinaryOperator.rShrink(LIntUnaryOperator right)
static LIntUnaryOperator	LIntBinaryOperator.rShrinked(LIntUnaryOperator right, LIntBinaryOperator func)
default LIntBinaryOperator	LIntBinaryOperator.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.

Method parameters in eu.lunisolar.magma.func.operator.binary with type arguments of type LIntUnaryOperator

Modifier and Type	Method and Description
static LIntBinaryOperator	LIntBinaryOperator.uncurry(LIntFunction<LIntUnaryOperator> func)

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

Classes in eu.lunisolar.magma.func.operator.unary that implement LIntUnaryOperator

Modifier and Type	Class and Description
static class	LIntUnaryOperator.LIntUnaryOperatorSingle

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

Modifier and Type	Method and Description
default LIntUnaryOperator	LIntUnaryOperator.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntUnaryOperator	LIntUnaryOperator.composed(LIntUnaryOperator before, LIntUnaryOperator after)
static LIntUnaryOperator	LIntUnaryOperator.constant(int r) Creates function that always returns the same value.
static LIntUnaryOperator	LIntUnaryOperator.failSafe(LIntUnaryOperator func, LIntUnaryOperator failSafe)
default LIntUnaryOperator	LIntUnaryOperator.handling(HandlingInstructions<Throwable,RuntimeException> handling)
static LIntUnaryOperator	LIntUnaryOperator.identity() Returns a function that always returns its input argument.
static LIntUnaryOperator	LIntUnaryOperator.intUnaryOp(LIntUnaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static LIntUnaryOperator	LIntUnaryOperator.intUnaryOpThrowing(ExF<Throwable> exF)
static LIntUnaryOperator	LIntUnaryOperator.intUnaryOpThrowing(String message, ExMF<Throwable> exF)
static LIntUnaryOperator	LIntUnaryOperator.recursive(LFunction<LIntUnaryOperator,LIntUnaryOperator> selfLambda)
static LIntUnaryOperator	LIntUnaryOperator.safe() Safe instance.
static LIntUnaryOperator	LIntUnaryOperator.safe(LIntUnaryOperator other) Safe wrapping.
default LIntUnaryOperator	LIntUnaryOperator.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
default LIntUnaryOperator	LIntUnaryOperator.trying(ExWF<RuntimeException> exF)
default LIntUnaryOperator	LIntUnaryOperator.trying(ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
default LIntUnaryOperator	LIntUnaryOperator.tryingThen(LToIntFunction<Throwable> handler)
LIntUnaryOperator	LIntUnaryOperator.LIntUnaryOperatorSingle.value()
static LIntUnaryOperator	LIntUnaryOperator.wrap(java.util.function.IntUnaryOperator other) Wraps JRE instance.

Methods in eu.lunisolar.magma.func.operator.unary that return types with arguments of type LIntUnaryOperator

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

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

Modifier and Type	Method and Description
static int	LIntUnaryOperator.call(int a, LIntUnaryOperator lambda)
default LIntUnaryOperator	LIntUnaryOperator.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
static LIntUnaryOperator	LIntUnaryOperator.composed(LIntUnaryOperator before, LIntUnaryOperator after)
static <V> LToIntFunction<V>	LIntUnaryOperator.composed(LToIntFunction<? super V> before, LIntUnaryOperator after)
static LIntUnaryOperator	LIntUnaryOperator.failSafe(LIntUnaryOperator func, LIntUnaryOperator failSafe)
default int	LIntUnaryOperator.failSafeApplyAsInt(int a, LIntUnaryOperator failSafe)
static int	LIntUnaryOperator.failSafeApplyAsInt(int a, LIntUnaryOperator func, LIntUnaryOperator failSafe)
static void	LIntUnaryOperator.fromTill(int min_a, int max_a, LIntUnaryOperator func) From-To.
static void	LIntUnaryOperator.fromTo(int min_a, int max_a, LIntUnaryOperator func) From-To.
static int	LIntUnaryOperator.handlingApplyAsInt(int a, LIntUnaryOperator func, HandlingInstructions<Throwable,RuntimeException> handling)
static LIntUnaryOperator	LIntUnaryOperator.intUnaryOp(LIntUnaryOperator lambda) Convenient method in case lambda expression is ambiguous for the compiler (that might happen for overloaded methods accepting different interfaces).
static LIntUnaryOperator	LIntUnaryOperator.safe(LIntUnaryOperator other) Safe wrapping.
default LIntUnaryOperator	LIntUnaryOperator.thenToInt(LIntUnaryOperator after) Combines two functions together in a order.
static void	LIntUnaryOperator.times(int max_a, LIntUnaryOperator func) From-To.
static int	LIntUnaryOperator.tryApplyAsInt(int a, LIntUnaryOperator func)
static int	LIntUnaryOperator.tryApplyAsInt(int a, LIntUnaryOperator func, ExWF<RuntimeException> exF)
static int	LIntUnaryOperator.tryApplyAsInt(int a, LIntUnaryOperator func, ExWMF<RuntimeException> exF, String newMessage, Object... messageParams)
static int	LIntUnaryOperator.tryApplyAsIntThen(int a, LIntUnaryOperator func, LToIntFunction<Throwable> handler)

Method parameters in eu.lunisolar.magma.func.operator.unary with type arguments of type LIntUnaryOperator

Modifier and Type	Method and Description
static LIntUnaryOperator	LIntUnaryOperator.recursive(LFunction<LIntUnaryOperator,LIntUnaryOperator> selfLambda)
static LIntUnaryOperator	LIntUnaryOperator.recursive(LFunction<LIntUnaryOperator,LIntUnaryOperator> selfLambda)
static LSupplier<LIntUnaryOperator>	LIntUnaryOperator.safeSupplier(LSupplier<LIntUnaryOperator> supplier) Safe supplier.

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

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

Modifier and Type	Method and Description
default LIntUnaryOperator	LIntPredicate.boolToIntUnaryOp(LBoolToIntFunction after) Combines two functions together in a order.

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

Modifier and Type	Method and Description
default LByteIntPredicate	LByteIntPredicate.compose(LByteUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LCharIntPredicate	LCharIntPredicate.compose(LCharUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LDblIntPredicate	LDblIntPredicate.compose(LDblUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LFltIntPredicate	LFltIntPredicate.compose(LFltUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntPredicate<V1>	LObjIntPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default <V1> LObjIntBytePredicate<V1>	LObjIntBytePredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntCharPredicate<V1>	LObjIntCharPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntDblPredicate<V1>	LObjIntDblPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntFltPredicate<V1>	LObjIntFltPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjBiIntPredicate<V1>	LObjBiIntPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntBoolPredicate<V1>	LObjIntBoolPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntLongPredicate<V1>	LObjIntLongPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1> LObjIntSrtPredicate<V1>	LObjIntSrtPredicate.compose(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.compose(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3) Allows to manipulate the domain of the function.
default <V1,V3> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.compose(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3) Allows to manipulate the domain of the function.
default LIntPredicate	LIntPredicate.compose(LIntUnaryOperator before) Allows to manipulate the domain of the function.
default LBiIntPredicate	LBiIntPredicate.compose(LIntUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LBoolIntPredicate	LBoolIntPredicate.compose(LLogicalOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LLongIntPredicate	LLongIntPredicate.compose(LLongUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
default LSrtIntPredicate	LSrtIntPredicate.compose(LSrtUnaryOperator before1, LIntUnaryOperator before2) Allows to manipulate the domain of the function.
static LByteIntPredicate	LByteIntPredicate.composed(LByteUnaryOperator before1, LIntUnaryOperator before2, LByteIntPredicate after)
static LCharIntPredicate	LCharIntPredicate.composed(LCharUnaryOperator before1, LIntUnaryOperator before2, LCharIntPredicate after)
static LDblIntPredicate	LDblIntPredicate.composed(LDblUnaryOperator before1, LIntUnaryOperator before2, LDblIntPredicate after)
static LFltIntPredicate	LFltIntPredicate.composed(LFltUnaryOperator before1, LIntUnaryOperator before2, LFltIntPredicate after)
static <V1,T> LObjIntBytePredicate<V1>	LObjIntBytePredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LByteUnaryOperator before3, LObjIntBytePredicate<T> after)
static <V1,T> LObjIntCharPredicate<V1>	LObjIntCharPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LCharUnaryOperator before3, LObjIntCharPredicate<T> after)
static <V1,T> LObjIntDblPredicate<V1>	LObjIntDblPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LDblUnaryOperator before3, LObjIntDblPredicate<T> after)
static <V1,T> LObjIntFltPredicate<V1>	LObjIntFltPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LFltUnaryOperator before3, LObjIntFltPredicate<T> after)
static <V1,T> LObjBiIntPredicate<V1>	LObjBiIntPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LIntUnaryOperator before3, LObjBiIntPredicate<T> after)
static <V1,T> LObjIntBoolPredicate<V1>	LObjIntBoolPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLogicalOperator before3, LObjIntBoolPredicate<T> after)
static <V1,T> LObjIntLongPredicate<V1>	LObjIntLongPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LLongUnaryOperator before3, LObjIntLongPredicate<T> after)
static <V1,T> LObjIntPredicate<V1>	LObjIntPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LObjIntPredicate<T> after)
static <V1,T> LObjIntSrtPredicate<V1>	LObjIntSrtPredicate.composed(LFunction<? super V1,? extends T> before1, LIntUnaryOperator before2, LSrtUnaryOperator before3, LObjIntSrtPredicate<T> after)
static <V1,V2,T1,T2> LBiObjIntPredicate<V1,V2>	LBiObjIntPredicate.composed(LFunction<? super V1,? extends T1> before1, LFunction<? super V2,? extends T2> before2, LIntUnaryOperator before3, LBiObjIntPredicate<T1,T2> after)
static <V1,V3,T1,T2> LObjIntObjPredicate<V1,V3>	LObjIntObjPredicate.composed(LFunction<? super V1,? extends T1> before1, LIntUnaryOperator before2, LFunction<? super V3,? extends T2> before3, LObjIntObjPredicate<T1,T2> after)
static LIntPredicate	LIntPredicate.composed(LIntUnaryOperator before, LIntPredicate after)
static LBiIntPredicate	LBiIntPredicate.composed(LIntUnaryOperator before1, LIntUnaryOperator before2, LBiIntPredicate after)
static LBoolIntPredicate	LBoolIntPredicate.composed(LLogicalOperator before1, LIntUnaryOperator before2, LBoolIntPredicate after)
static LLongIntPredicate	LLongIntPredicate.composed(LLongUnaryOperator before1, LIntUnaryOperator before2, LLongIntPredicate after)
static LSrtIntPredicate	LSrtIntPredicate.composed(LSrtUnaryOperator before1, LIntUnaryOperator before2, LSrtIntPredicate after)
default LIntPredicate	LBiIntPredicate.lShrink(LIntUnaryOperator left)
static LIntPredicate	LBiIntPredicate.lShrinked(LIntUnaryOperator left, LBiIntPredicate func)
default LIntPredicate	LBiIntPredicate.rShrink(LIntUnaryOperator right)
static LIntPredicate	LBiIntPredicate.rShrinked(LIntUnaryOperator right, LBiIntPredicate func)

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

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

Modifier and Type	Method and Description
default LIntSupplier	LIntSupplier.toIntSup(LIntUnaryOperator after) Combines two functions together in a order.