如何在 Scala 中比较浮点值？

发布于 2024-12-19 17:02:20 字数 571 浏览 5 评论 0原文

据我所知，精确比较对于浮点值没有多大意义，因为 0.0001 实际上可能是 0.0001000...0001...我应该实现自己的比较函数来指定精度还是这有一个常见的做法吗？

我曾经在 C# 中使用以下内容（我怀疑这仍然是错误的，因为 Double 值可能根本无法表示 0.0001，甚至设置为常量（正如 Michael Borgwardt 所解释的此处））：

public static bool AlmostEquals(this double x, double y, double precision = 0.0001)
{
  if (precision < 0.0)
    throw new ArgumentException();

  return Math.Abs(x - y) <= precision;
}

我应该这样做吗Scala 有类似的东西吗？

原文

As far as I know, exact comparison doesn't make much sense with floating point values as what is intended to be 0.0001 can actually be something like 0.0001000...0001... Should I implement my own comparison function to specify precision or is there a common practice for this?

I used to use the following with C# (which, I suspect, is still wrong as a Double value can be probably uncapable of representing 0.0001 at all, even set as a constant (as Michael Borgwardt explained here)):

public static bool AlmostEquals(this double x, double y, double precision = 0.0001)
{
  if (precision < 0.0)
    throw new ArgumentException();

  return Math.Abs(x - y) <= precision;
}

Should I do something alike in Scala?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

浪漫之都 2024-12-26 17:02:20

是的，您可以做与 Java 中相同的事情。您还可以使用 Scala 的一些很酷的功能，并使用 ~= 方法来修饰 Double 类，该方法采用只需指定一次的隐式精度参数。

scala> case class Precision(val p:Double)
defined class Precision

scala> class withAlmostEquals(d:Double) {
  def ~=(d2:Double)(implicit p:Precision) = (d-d2).abs <= p.p
}
defined class withAlmostEquals

scala> implicit def add_~=(d:Double) = new withAlmostEquals(d)
add_$tilde$eq: (d: Double)withAlmostEquals

scala> 0.0~=0.0
<console>:12: error: could not find implicit value for parameter p: Precision
              0.0~=0.0
                 ^

scala> implicit val precision = Precision(0.001)
precision: Precision = Precision(0.001)

scala> 0.0 ~= 0.00001
res1: Boolean = true

Yes, you can do the same thing as in Java. You could also use some of Scala's cool features and pimp the Double class with a ~= method that takes an implicit precision parameter that only needs to be specified once.

scala> case class Precision(val p:Double)
defined class Precision

scala> class withAlmostEquals(d:Double) {
  def ~=(d2:Double)(implicit p:Precision) = (d-d2).abs <= p.p
}
defined class withAlmostEquals

scala> implicit def add_~=(d:Double) = new withAlmostEquals(d)
add_$tilde$eq: (d: Double)withAlmostEquals

scala> 0.0~=0.0
<console>:12: error: could not find implicit value for parameter p: Precision
              0.0~=0.0
                 ^

scala> implicit val precision = Precision(0.001)
precision: Precision = Precision(0.001)

scala> 0.0 ~= 0.00001
res1: Boolean = true

回复收藏 0 原文

天生の放荡 2024-12-26 17:02:20

使用来自 scalautils

import org.scalautils._
import TripleEquals._
import Tolerance._

val result = 2.000001

结果的公差：Double = 2.000001

result === 2.0 +- .001

res0: Boolean = true

result === 2.0 +- .000000001

res1: Boolean = false

更新：对于 Scala 2.11

import org.scalatest._
import org.scalatest.Matchers._
val r = 4
val rr = (r === 2 +- 1)

r: Int = 4 
rr: Boolean = false

Use Tolerance from scalautils

import org.scalautils._
import TripleEquals._
import Tolerance._

val result = 2.000001

result: Double = 2.000001

result === 2.0 +- .001

res0: Boolean = true

result === 2.0 +- .000000001

res1: Boolean = false

Update: For Scala 2.11

import org.scalatest._
import org.scalatest.Matchers._
val r = 4
val rr = (r === 2 +- 1)

r: Int = 4 
rr: Boolean = false

回复收藏 0 原文

菊凝晚露 2024-12-26 17:02:20

或者使用 2.10...

case class Precision(p:Double)

implicit class DoubleWithAlmostEquals(val d:Double) extends AnyVal {
  def ~=(d2:Double)(implicit p:Precision) = (d - d2).abs < p.p
}

Or with 2.10...

case class Precision(p:Double)

implicit class DoubleWithAlmostEquals(val d:Double) extends AnyVal {
  def ~=(d2:Double)(implicit p:Precision) = (d - d2).abs < p.p
}

回复收藏 0 原文

~没有更多了~