覆盖Scala中浮点值的相等性

Question

注意：请耐心等待，我不是在问如何覆盖 equals 或如何创建自定义方法来比较浮点值。

Scala 在允许按值比较对象方面非常出色，并提供了一系列工具来用很少的代码来实现这一点。特别是案例类、元组和允许比较整个集合。

我经常调用进行密集计算并生成要返回的重要数据结构的方法，然后我可以编写一个单元测试，在给定特定输入的情况下将调用该方法，然后将结果与硬编码值进行比较。例如：

def compute() =
{
   // do a lot of computations here to produce the set below...
   Set(('a', 1), ('b', 3))
}

val A = compute()
val equal = A == Set(('a', 1), ('b', 3))  
// equal = true

这是一个简单的示例，我在这里省略了来自特定测试库等的任何代码。 鉴于浮点值不能可靠地与 equals 进行比较，以下相当等价的示例会失败：

def compute() =
{
   // do a lot of computations here to produce the set below...
   Set(('a', 1.0/3.0), ('b', 3.1))
}

val A = compute()
val equal2 = A == Set(('a', 0.33333), ('b', 3.1))  // Use some arbitrary precision here
// equal2 = false

我想要的是有一种方法可以在该调用中进行所有浮点比较，以使用任意级别的精度。但请注意，我不控制（或想以任何方式改变）Set 或 Double。

我尝试定义从 double 到新类的隐式转换，然后重载该类以返回 true。然后我可以在我的硬编码验证中使用该类的实例。

implicit class DoubleAprox(d: Double)
{
   override def hashCode = d.hashCode()
   override def equals(other : Any) : Boolean = other match {
      case that : Double => (d - that).abs < 1e-5
      case _ => false
   }
}

val equals3 = DoubleAprox(1.0/3.0) == 0.33333  // true
val equals4 = 1.33333 == DoubleAprox(1.0/3.0)  // false

但正如您所见，它破坏了对称性。鉴于我正在比较更复杂的数据结构（集合、元组、案例类），如果equals() 将在左侧或右侧调用，我无法先验地定义。似乎我必须遍历所有结构，然后在分支上进行单浮点比较......所以，问题是：有没有办法做到这一点？？

---

附带说明：我很好地阅读了entire chapter on object equality 和几个博客，但它们只提供了继承问题的解决方案，并且要求您基本上拥有所有涉及的类并更改所有这些类。考虑到它试图解决的问题，所有这些似乎都相当复杂。

在我看来，平等是 Java 中根本被破坏的事情之一，因为必须将方法添加到每个类并一次又一次地永久覆盖。对我来说更直观的是拥有编译器可以找到的比较方法。比如说，您将提供 equals(DoubleAprox, Double) 并且每次您想比较这些类的 2 个对象时都会使用它。

Answer 1

我认为将相等的含义改为模糊的含义是个坏主意。请参阅Equals for case class with floating point fields 中的我的 cmets 了解原因。

但是，在非常有限的范围内执行此操作是有意义的，例如用于检测。我认为对于数值问题，您应该考虑使用 spire library 作为依赖项。它包含大量有用的东西。其中包括用于相等的类型类和基于各个标量类型的类型类实例为复合类型（集合、元组等）派生类型类实例的机制。

正如您所观察到的，Java 世界中的相等性从根本上被破坏了，它们正在使用其他运算符（=== 用于类型安全的相等性）。

这是一个示例，您将如何在有限范围内重新定义相等性以获得模糊相等性以比较测试结果：

// import the machinery for operators like === (when an Eq type class instance is in scope)
import spire.syntax.all._

object Test extends App {
  // redefine the equality for double, just in this scope, to mean fuzzy equali
  implicit object FuzzyDoubleEq extends spire.algebra.Eq[Double] {
    def eqv(a:Double, b:Double) = (a-b).abs < 1e-5
  }

  // this passes. === looks up the Eq instance for Double in the implicit scope. And 
  // since we have not imported the default instance but defined our own, this will
  // find the Eq instance defined above and use its eqv method
  require(0.0 === 0.000001)

  // import automatic generation of type class instances for tuples based on type class instances of the scalars
  // if there is an Eq available for each scalar type of the tuple, this will also make an Eq instance available for the tuple
  import spire.std.tuples._
  require((0.0, 0.0) === (0.000001, 0.0)) // works also for tuples containing doubles

  // import automatic generation of type class instances for arrays based on type class instances of the scalars
  // if there is an Eq instance for the element type of the array, there will also be one for the entire array
  import spire.std.array._
  require(Array(0.0,1.0) === Array(0.000001, 1.0)) // and for arrays of doubles

  import spire.std.seq._
  require(Seq(1.0, 0.0) === Seq(1.000000001, 0.0))
}

Answer 2

Java equals 确实没有应有的原则 - 对此非常困扰的人使用类似 Scalaz 的 Equal 和 ===。但即使这样也假设所涉及的类型是对称的；我认为您必须编写一个自定义类型类来允许比较异构类型。

使用Shapeless'automatic type class instance derivation，编写一个新的类型类并为案例类递归派生实例非常容易。不过，我不确定它是否扩展到双参数类型类。您可能会发现最好创建不同的EqualityLHS 和EqualityRHS 类型类，然后使用您自己的相等方法来比较A: EqualityLHS 和B: EqualityRHS，如果需要，可以将其作为运算符添加到A。 （当然，应该可以扩展该技术以完全通用地支持双参数类型类，而不需要这样的变通方法，我相信 shapeless 会非常感谢这样的贡献）。

祝你好运 - 希望这能让你自己找到答案的其余部分。您想要做的事情绝不是微不足道的，但在现代 Scala 技术的帮助下，它应该是非常可行的。