de.caff.generics.function

Interface FloatOrdering

All Known Subinterfaces:

DoubleOrdering, DoubleOrdering.Serial, FloatOrdering.Serial

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface FloatOrdering

Define an order for two primitive float values.

Compared to a Comparator<Float> this can avoid boxing and unboxing in various situations.

Since:

January 11, 2023

Author:

Rammi

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	FloatOrdering.Serial A float ordering which is serializable.

Field Summary

Fields

Modifier and Type	Field and Description
static FloatOrdering	NATURAL_ASCENDING Natural order of ascending float values.
static FloatOrdering	NATURAL_DESCENDING Natural order of descending float values.
static FloatOrdering	STANDARD_ASCENDING Standard Java order of ascending float values.
static FloatOrdering	STANDARD_DESCENDING Inverse standard Java order of float values.

Method Summary

Modifier and Type	Method and Description
default boolean	ascending(float v1, float v2) Are the two values represented in strictly ascending order?
default boolean	ascendingOrSame(float v1, float v2) Are the two values represented in ascending order?
default java.util.Comparator<java.lang.Float>	asFloatComparator() Use this ordering as a comparator.
default Ordering<java.lang.Float>	asFloatOrdering() Get this ordering as a generic float ordering.
default java.util.Comparator<java.lang.Number>	asNumberComparator() View this ordering as a number comparator.
Order	checkFloat(float v1, float v2) Get the order of the two values.
default boolean	descending(float v1, float v2) Are the two values represented in strictly descending order?
default boolean	descendingOrSame(float v1, float v2) Are the two values represented in descending order?
default boolean	different(float v1, float v2) Are the two values considered different by this order?
static FloatOrdering	fromComparator(java.util.Comparator<java.lang.Float> comparator) Convert a standard comparator of Double into a double ordering.
default FloatOrdering	inverse() Invert this order.
default boolean	same(float v1, float v2) Are the two values considered equal by this order?

Field Detail

NATURAL_ASCENDING

static final FloatOrdering NATURAL_ASCENDING

Natural order of ascending float values. Besides collapsing all NaN values and ordering them between everything else this ordering is nearer to IEEE 784 than standard Float.compare(float, float).

See Also:

Primitives.order(float, float), STANDARD_ASCENDING

NATURAL_DESCENDING

static final FloatOrdering NATURAL_DESCENDING

Natural order of descending float values. Besides collapsing all NaN values and ordering them before everything else this ordering is nearer to IEEE 784 than standard Float.compare(float, float).

See Also:

Primitives.order(float, float), STANDARD_DESCENDING

STANDARD_ASCENDING

static final FloatOrdering STANDARD_ASCENDING

Standard Java order of ascending float values. Please note that this order is broken as it considers -0.0 < 0.0 which is not correct, for primitive float values -0.0 == 0.0 is valid.

See Also:

NATURAL_ASCENDING

STANDARD_DESCENDING

static final FloatOrdering STANDARD_DESCENDING

Inverse standard Java order of float values. Please note that this order is broken as it considers -0.0 < 0.0 which is not correct, for primitive float values -0.0 == 0.0 is valid.

Method Detail

checkFloat

@NotNull
Order checkFloat(float v1,
                          float v2)

Get the order of the two values.

Parameters:

v1 - first value

v2 - second value

Returns:

order of the two values

ascending

default boolean ascending(float v1,
                          float v2)

Are the two values represented in strictly ascending order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 < v2 according to this ordering
false if v1 >= v2 according to this ordering

See Also:

descending(float, float), ascendingOrSame(float, float), descendingOrSame(float, float), same(float, float), different(float, float)

ascendingOrSame

default boolean ascendingOrSame(float v1,
                                float v2)

Are the two values represented in ascending order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 <= v2 according to this ordering
false if v1 > v2 according to this ordering

See Also:

ascending(float, float), descending(float, float), descendingOrSame(float, float), same(float, float), different(float, float)

descending

default boolean descending(float v1,
                           float v2)

Are the two values represented in strictly descending order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 > v2 according to this ordering
false if v1 <= v2 according to this ordering

See Also:

ascending(float, float), ascendingOrSame(float, float), descendingOrSame(float, float), same(float, float), different(float, float)

descendingOrSame

default boolean descendingOrSame(float v1,
                                 float v2)

Are the two values represented in descending order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 >= v2 according to this ordering
false if v1 < v2 according to this ordering

See Also:

ascending(float, float), descending(float, float), ascendingOrSame(float, float), same(float, float), different(float, float)

same

default boolean same(float v1,
                     float v2)

Are the two values considered equal by this order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 == v2 according to this order
false if v1 != v2 according to this ordering

See Also:

ascending(float, float), descending(float, float), ascendingOrSame(float, float), descendingOrSame(float, float), different(float, float)

different

default boolean different(float v1,
                          float v2)

Are the two values considered different by this order?

Parameters:

v1 - first value

v2 - second value

Returns:

true if v1 != v2 according to this order
false if v1 == v2 according to this ordering

See Also:

ascending(float, float), descending(float, float), ascendingOrSame(float, float), descendingOrSame(float, float), same(float, float)

inverse

@NotNull
default FloatOrdering inverse()

Invert this order.

Returns:

inverse order

asFloatComparator

@NotNull
default java.util.Comparator<java.lang.Float> asFloatComparator()

Use this ordering as a comparator.

Returns:

comparator of Float

asNumberComparator

@NotNull
default java.util.Comparator<java.lang.Number> asNumberComparator()

View this ordering as a number comparator.

Returns:

comparator of Number

asFloatOrdering

@NotNull
default Ordering<java.lang.Float> asFloatOrdering()

Get this ordering as a generic float ordering.

Returns:

generic ordering for floats

fromComparator

@NotNull
static FloatOrdering fromComparator(@NotNull
                                             java.util.Comparator<java.lang.Float> comparator)

Convert a standard comparator of Double into a double ordering.

Parameters:

comparator - comparator of Double

Returns:

ordering