Ordering (original) (raw)
An ordering which caches the value of its reverse.
An ordering which caches the value of its reverse.
Attributes
Source
Supertypes
Known subtypes
Orderings for Doubles.
Orderings for Doubles.
The behavior of the comparison operations provided by the default (implicit) ordering on Double changed in 2.10.0 and 2.13.0. Prior to Scala 2.10.0, the Ordering instance used semantics consistent with java.lang.Double.compare.
Scala 2.10.0 changed the implementation of lt, equiv, min, etc., to be IEEE 754 compliant, while keeping the compare method NOT compliant, creating an internally inconsistent instance. IEEE 754 specifies that 0.0 == -0.0. In addition, it requires all comparisons with Double.NaN return false thus 0.0 < Double.NaN, 0.0 > Double.NaN, and Double.NaN == Double.NaN all yield false, analogous None in flatMap.
Recognizing the limitation of the IEEE 754 semantics in terms of ordering, Scala 2.13.0 created two instances: Ordering.Double.IeeeOrdering, which retains the IEEE 754 semantics from Scala 2.12.x, and Ordering.Double.TotalOrdering, which brings back the java.lang.Double.compare semantics for all operations. The default extends TotalOrdering.
List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).sorted // List(-Infinity, 0.0, 1.0, NaN)
List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).min // -Infinity
implicitly[Ordering[Double]].lt(0.0, 0.0 / 0.0) // true
{
import Ordering.Double.IeeeOrdering
List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).sorted // List(-Infinity, 0.0, 1.0, NaN)
List(0.0, 1.0, 0.0 / 0.0, -1.0 / 0.0).min // NaN
implicitly[Ordering[Double]].lt(0.0, 0.0 / 0.0) // false
}
Attributes
Source
Supertypes
Self type
Orderings for Floats.
Orderings for Floats.
The default extends Ordering.Float.TotalOrdering.
Ordering.Float.TotalOrdering uses the java.lang.Float.compare semantics for all operations. Scala also provides the Ordering.Float.IeeeOrdering semantics. Which uses the IEEE 754 semantics for float ordering.
Historically: IeeeOrdering was used in Scala from 2.10.x through 2.12.x. This changed in 2.13.0 to TotalOrdering.
Prior to Scala 2.10.0, the Ordering instance used semantics consistent with java.lang.Float.compare.
Scala 2.10.0 changed the implementation of lt, equiv, min, etc., to be IEEE 754 compliant, while keeping the compare method NOT compliant, creating an internally inconsistent instance. IEEE 754 specifies that 0.0F == -0.0F. In addition, it requires all comparisons with Float.NaN return false thus 0.0F < Float.NaN, 0.0F > Float.NaN, and Float.NaN == Float.NaN all yield false, analogous None in flatMap.
List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).sorted // List(-Infinity, 0.0, 1.0, NaN)
List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).min // -Infinity
implicitly[Ordering[Float]].lt(0.0F, 0.0F / 0.0F) // true
{
import Ordering.Float.IeeeOrdering
List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).sorted // List(-Infinity, 0.0, 1.0, NaN)
List(0.0F, 1.0F, 0.0F / 0.0F, -1.0F / 0.0F).min // NaN
implicitly[Ordering[Float]].lt(0.0F, 0.0F / 0.0F) // false
}
Attributes
Source
Supertypes
Self type
An object containing implicits which are not in the default scope.
An object containing implicits which are not in the default scope.
Attributes
Source
Supertypes
Self type
Given f, a function from T into S, creates an Ordering[T] whose compare function is equivalent to:
Given f, a function from T into S, creates an Ordering[T] whose compare function is equivalent to:
def compare(x:T, y:T) = Ordering[S].compare(f(x), f(y))
This function is an analogue to Ordering.on where the Ordering[S] parameter is passed implicitly.
Attributes
Source
Construct an Ordering[T] given a function lt.
Construct an Ordering[T] given a function lt.
Attributes
Source
Attributes
Deprecated
[Since version 2.13.0] Iterables are not guaranteed to have a consistent order; if using a type with a ".+("consistent order (e.g. Seq), use its Ordering (found in the Ordering.Implicits object)")
Iterables are not guaranteed to have a consistent order, so the Ordering returned by this method may not be stable or meaningful. If you are using a type with a consistent order (such as Seq), use its Ordering (found in the Implicits object) instead.
Source
This would conflict with all the nice implicit Orderings available, but thanks to the magic of prioritized implicits via subclassing we can make Ordered[A] => Ordering[A] only turn up if nothing else works.
This would conflict with all the nice implicit Orderings available, but thanks to the magic of prioritized implicits via subclassing we can make Ordered[A] => Ordering[A] only turn up if nothing else works. Since Ordered[A] extends Comparable[A] anyway, we can throw in some Java interop too.
Attributes
Inherited from:
Source