浮动步的标量范围精度

Question

I intend to generate an array from 0.05 to 0.95 with step 0.05, just like 0.05, 0.1, 0.15, 0.2, ... . But the following code has some precision problems:

scala> 0.05 to 0.95 by 0.05
res11: scala.collection.immutable.NumericRange[Double] = NumericRange(0.05, 0.1, 0.15000000000000002, 0.2, 0.25, 0.3, 0.35, 0.39999999999999997, 0.44999999999999996, 0.49999999999999994, 0.5499999999999999, 0.6, 0.65, 0.7000000000000001, 0.7500000000000001, 0.8000000000000002, 0.8500000000000002, 0.9000000000000002)

Could anyone give me some idea on how to solve this problem? Thanks.

Answer 1

If you need precise decimal calculations, the actually reliable way is to use BigDecimal :

BigDecimal("0.05") to BigDecimal("0.95") by BigDecimal("0.05")

It's a lot slower, so not acceptable in some contexts, but that's the reality of working with decimals on modern computers.

Answer 2

You could use rounding to get job done:

scala> (0.05 to 0.95 by 0.05) map ( x=> "%.2f".formatLocal(java.util.Locale.ROOT,x).toDouble)
res0: scala.collection.immutable.IndexedSeq[Double] = Vector(0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9)

Answer 3

a more logical explanation could be this

for(i <-  (0.05 to 0.96 by 0.05)) yield "%.2f".format(i)
res36: scala.collection.immutable.IndexedSeq[String] = Vector(0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95)

Answer 4

If I interpret your question correctly, the problem isn't that 0.15 is notated as 0.15000000000000002, but rather that the max value (0.95) is not actually produced. This is an annoying interaction between range and floating point precision, and there's no easy way to get around it. I've written one solution below, though it's pretty hacky. It's a little less efficient than the default numeric range, but still indexes elements in constant time.

REPL:

scala> class PreciseDoubleRange(start: Double, end: Double, by: Double, precision: Int = 4) extends IndexedSeq[Double] {
  val precisionScalar = math.pow(10, precision).toLong
  val steps = ((end - start) / by + 1.0 / precisionScalar).toInt

  def length: Int = steps + 1

  def apply(idx: Int): Double = 
    math.round((start + (idx * by)) * precisionScalar).toDouble / precisionScalar
}
defined class PreciseDoubleRange

scala> new PreciseDoubleRange(0.05, 0.95, 0.05)
res11: PreciseDoubleRange = (0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 
  0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95)

Answer 5

Yeah the floating point precision bites you here especially with when trying to generate the last element of the range. .950000000002 gets cut off because it's greater than the .95 you specified.

While it doesn't read as nicely, what I've found to behave much more consistently in Scala is to use integer ranges exclusively, and just use a for comprehension to yield the computed results you want.

So something like 0.05 to 0.95 by 0.05 can be transformed into for (i <- 1 to 19) yield i.toFloat / 20 .

In general something like start to end by step transforms into for (i <- (start / step) to (end / step)) yield i.toFloat / (1/step) should work but it's not strictly general if step doesn't divide both start and end evenly but in that case you're clearly just being difficult.

In any case, I think the reason this works much better is that dividing introduces less imprecision than taking a product of a number (the step) that can't be represented exactly.