ArraySeq.ofFloat/ofDouble have wrong equals behavior

[eejbyfeldt]

Reproduction steps

Scala version: 3.7.0 (but the bug is in the standard library)

scala> import scala.collection.immutable.ArraySeq
                                                                                              
scala> ArraySeq(0.0f) == ArraySeq(-0.0f)
val res0: Boolean = false
                                                                                              
scala> ArraySeq(0.0f).map(identity) == ArraySeq(-0.0f)
val res1: Boolean = true

Problem

ArraySeq equals should use == for floating point that follow IEEE semantics as done by Other Seqs.

The problem is that the specialization ofFloat and ofDouble delegate equals to java.util.Arrays.equals but that is documented to not follow the normal == behavior https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#equals-double:A-double:A-

[som-snytt]

scala> ArraySeq(0.0f).sameElements(ArraySeq(-0.0f))
val res1: Boolean = true

scala> Double.NaN == Double.NaN
val res2: Boolean = false

scala> ArraySeq(0.0f, Double.NaN).sameElements(ArraySeq(-0.0f, Double.NaN))
val res3: Boolean = false

scala> ArraySeq(Double.NaN) == ArraySeq(Double.NaN)
val res4: Boolean = true

The linked discussion at https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/Double.html#equivalenceRelation says the other use case is collections:

scala> val vs = mutable.Set.empty[ArraySeq[Float]]
val vs: scala.collection.mutable.Set[scala.collection.immutable.ArraySeq[Float]] = HashSet()

scala> vs.addOne(ArraySeq(0.0f))
val res5: vs.type = HashSet(ArraySeq(0.0))

scala> vs(ArraySeq(-0.0f))
val res6: Boolean = false

[eejbyfeldt]

Hm I also just realized that because eq optimization in Seq and case classes you get really unexpected behavior when comparing values containing Double.NaN

scala> val l = Seq(Double.NaN)
val l: Seq[Double] = List(NaN)
                                                                                              
scala> l.head == l.head
val res5: Boolean = false
                                                                                              
scala> l == l
val res6: Boolean = true
                                                                                              
scala> l == Seq(Double.NaN)
val res7: Boolean = false

and

scala> final case class Wrapper(d: Double)
// defined case class Wrapper
                                                                                              
scala> val w = Wrapper(Double.NaN)
val w: Wrapper = Wrapper(NaN)
                                                                                              
scala> w == w
val res8: Boolean = true
                                                                                              
scala> w.d == w.d
val res9: Boolean = false

[sjrd]

Yes, that's a long-standing issue with NaNs, that is basically unfixable.

NaN's basically have unexpected behavior all around. It's a major design issue for any language with NaN's and containers. There is no correct solution overall.

[som-snytt]

I'm not an expert, but my thought last week was that there is a difference between equals and "computational behavior".

I think there was a recent issue about distinguishing the type of literal -0; I remember sjrd commented.

Both NaN and -0 are special with respect to behavior.