Remove Float range and Double range

Fixes scala/bug#10781

At the basis of range is an assumption that summation works reliably. Unfortunately it is not true for IEEE floating point number where numbers are stored as approximate fraction of binary numbers. Natually, Double and Float ranges are completely broken. See numbers of issues such as scala/bug#8518, scala/bug#9875, scala/bug#9874, scala/bug#8620, scala/bug#8670, and scala/bug#10759.

I've attempted to fix the Double range in scala/collection-strawman#489 by faking it further using BigDecimal, but ultimately I was not able to overcome the fact that IEEE floats are not suited for ranges.

This removes both Float and Double ranges, as well as the fake `Integral[T]` instances that underpin their existence.

Author: eed3si9n

src/library/scala/collection/immutable/NumericRange.scala

@@ -212,18 +212,6 @@ extends AbstractSeq[T] with IndexedSeq[T] with Serializable {
           }
         ans.asInstanceOf[B]
       }
-      else if ((num eq scala.math.Numeric.FloatAsIfIntegral) ||
-               (num eq scala.math.Numeric.DoubleAsIfIntegral)) {
-        // Try to compute sum with reasonable accuracy, avoiding over/underflow
-        val numAsIntegral = num.asInstanceOf[Integral[B]]
-        import numAsIntegral._
-        val a = math.abs(head.toDouble)
-        val b = math.abs(last.toDouble)
-        val two = num fromInt 2
-        val nre = num fromInt numRangeElements
-        if (a > 1e38 || b > 1e38) nre * ((head / two) + (last / two))  // Compute in parts to avoid Infinity if possible
-        else (nre / two) * (head + last)    // Don't need to worry about infinity; this will be more accurate and avoid underflow
-      }
       else if ((num eq scala.math.Numeric.BigIntIsIntegral) ||
                (num eq scala.math.Numeric.BigDecimalIsFractional)) {
         // No overflow, so we can use arithmetic series formula directly
@@ -390,8 +378,6 @@ object NumericRange {
     Numeric.ByteIsIntegral -> Ordering.Byte,
     Numeric.CharIsIntegral -> Ordering.Char,
     Numeric.LongIsIntegral -> Ordering.Long,
-    Numeric.FloatAsIfIntegral -> Ordering.Float,
-    Numeric.DoubleAsIfIntegral -> Ordering.Double,
     Numeric.BigDecimalAsIfIntegral -> Ordering.BigDecimal
   )
 

src/library/scala/collection/immutable/Range.scala

@@ -480,24 +480,6 @@ object Range {
       NumericRange.inclusive(start, end, step)
   }
 
-  // Double works by using a BigDecimal under the hood for precise
-  // stepping, but mapping the sequence values back to doubles with
-  // .doubleValue.  This constructs the BigDecimals by way of the
-  // String constructor (valueOf) instead of the Double one, which
-  // is necessary to keep 0.3d at 0.3 as opposed to
-  // 0.299999999999999988897769753748434595763683319091796875 or so.
-  object Double {
-    implicit val bigDecAsIntegral = scala.math.Numeric.BigDecimalAsIfIntegral
-    implicit val doubleAsIntegral = scala.math.Numeric.DoubleAsIfIntegral
-    def toBD(x: Double): BigDecimal = scala.math.BigDecimal valueOf x
-
-    def apply(start: Double, end: Double, step: Double) =
-      BigDecimal(toBD(start), toBD(end), toBD(step)) mapRange (_.doubleValue)
-
-    def inclusive(start: Double, end: Double, step: Double) =
-      BigDecimal.inclusive(toBD(start), toBD(end), toBD(step)) mapRange (_.doubleValue)
-  }
-
   // As there is no appealing default step size for not-really-integral ranges,
   // we offer a partially constructed object.
   class Partial[T, U](private val f: T => U) extends AnyVal {

src/library/scala/math/Numeric.scala

@@ -143,13 +143,7 @@ object Numeric {
   trait FloatIsFractional extends FloatIsConflicted with Fractional[Float] {
     def div(x: Float, y: Float): Float = x / y
   }
-  trait FloatAsIfIntegral extends FloatIsConflicted with Integral[Float] {
-    def quot(x: Float, y: Float): Float = (BigDecimal(x.toDouble) quot BigDecimal(y.toDouble)).floatValue
-    def rem(x: Float, y: Float): Float = (BigDecimal(x.toDouble) remainder BigDecimal(y.toDouble)).floatValue
-  }
   implicit object FloatIsFractional extends FloatIsFractional with Ordering.FloatOrdering
-  object FloatAsIfIntegral extends FloatAsIfIntegral with Ordering.FloatOrdering {
-  }
 
   trait DoubleIsConflicted extends Numeric[Double] {
     def plus(x: Double, y: Double): Double = x + y
@@ -168,10 +162,6 @@ object Numeric {
   trait DoubleIsFractional extends DoubleIsConflicted with Fractional[Double] {
     def div(x: Double, y: Double): Double = x / y
   }
-  trait DoubleAsIfIntegral extends DoubleIsConflicted with Integral[Double] {
-    def quot(x: Double, y: Double): Double = (BigDecimal(x) quot BigDecimal(y)).doubleValue
-    def rem(x: Double, y: Double): Double = (BigDecimal(x) remainder BigDecimal(y)).doubleValue
-  }
 
   trait BigDecimalIsConflicted extends Numeric[BigDecimal] {
     def plus(x: BigDecimal, y: BigDecimal): BigDecimal = x + y
@@ -194,13 +184,12 @@ object Numeric {
     def rem(x: BigDecimal, y: BigDecimal): BigDecimal = x remainder y
   }
 
-  // For Double and BigDecimal we offer implicit Fractional objects, but also one
+  // For BigDecimal we offer implicit Fractional objects, but also one
   // which acts like an Integral type, which is useful in NumericRange.
   implicit object BigDecimalIsFractional extends BigDecimalIsFractional with Ordering.BigDecimalOrdering
   object BigDecimalAsIfIntegral extends BigDecimalAsIfIntegral with Ordering.BigDecimalOrdering
 
   implicit object DoubleIsFractional extends DoubleIsFractional with Ordering.DoubleOrdering
-  object DoubleAsIfIntegral extends DoubleAsIfIntegral with Ordering.DoubleOrdering
 }
 
 trait Numeric[T] extends Ordering[T] {

src/library/scala/runtime/RichDouble.scala

@@ -12,7 +12,6 @@ package runtime
 final class RichDouble(val self: Double) extends AnyVal with FractionalProxy[Double] {
   protected def num = scala.math.Numeric.DoubleIsFractional
   protected def ord = scala.math.Ordering.Double
-  protected def integralNum = scala.math.Numeric.DoubleAsIfIntegral
 
   override def doubleValue() = self
   override def floatValue()  = self.toFloat

src/library/scala/runtime/RichFloat.scala

@@ -12,7 +12,6 @@ package runtime
 final class RichFloat(val self: Float) extends AnyVal with FractionalProxy[Float] {
   protected def num         = scala.math.Numeric.FloatIsFractional
   protected def ord         = scala.math.Ordering.Float
-  protected def integralNum = scala.math.Numeric.FloatAsIfIntegral
 
   override def doubleValue() = self.toDouble
   override def floatValue()  = self

src/library/scala/runtime/ScalaNumberProxy.scala

@@ -53,21 +53,10 @@ trait IntegralProxy[T] extends Any with ScalaWholeNumberProxy[T] with RangedProx
   def to(end: T): NumericRange.Inclusive[T]             = NumericRange.inclusive(self, end, num.one)
   def to(end: T, step: T): NumericRange.Inclusive[T]    = NumericRange.inclusive(self, end, step)
 }
-trait FractionalProxy[T] extends Any with ScalaNumberProxy[T] with RangedProxy[T] {
+trait FractionalProxy[T] extends Any with ScalaNumberProxy[T] {
   protected implicit def num: Fractional[T]
-  protected implicit def integralNum: Integral[T]
-
-  /** In order to supply predictable ranges, we require an Integral[T] which provides
-   *  us with discrete operations on the (otherwise fractional) T.  See Numeric.DoubleAsIfIntegral
-   *  for an example.
-   */
-  type ResultWithoutStep = Range.Partial[T, NumericRange[T]]
 
   def isWhole() = false
-  def until(end: T): ResultWithoutStep                  = new Range.Partial(NumericRange(self, end, _))
-  def until(end: T, step: T): NumericRange.Exclusive[T] = NumericRange(self, end, step)
-  def to(end: T): ResultWithoutStep                     = new Range.Partial(NumericRange.inclusive(self, end, _))
-  def to(end: T, step: T): NumericRange.Inclusive[T]    = NumericRange.inclusive(self, end, step)
 }
 
 trait OrderedProxy[T] extends Any with Ordered[T] with Typed[T] {

test/files/presentation/infix-completion.check

@@ -3,8 +3,7 @@ reload: Snippet.scala
 askTypeCompletion at Snippet.scala(1,34)
 ================================================================================
 [response] askTypeCompletion at (1,34)
-retrieved 211 members
-[inaccessible] protected def integralNum: math.Numeric.DoubleAsIfIntegral.type
+retrieved 202 members
 [inaccessible] protected def num: math.Numeric.DoubleIsFractional.type
 [inaccessible] protected def ord: math.Ordering.Double.type
 [inaccessible] protected def unifiedPrimitiveEquals(x: Any): Boolean
@@ -140,10 +139,6 @@ def isValidLong: Boolean
 def longValue(): Long
 def round: Long
 def shortValue(): Short
-def to(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]]
-def to(end: Double,step: Double): scala.collection.immutable.NumericRange.Inclusive[Double]
-def to(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]]
-def to(end: Float,step: Float): scala.collection.immutable.NumericRange.Inclusive[Float]
 def to(end: Int): scala.collection.immutable.Range.Inclusive
 def to(end: Int,step: Int): scala.collection.immutable.Range.Inclusive
 def to(end: Long): scala.collection.immutable.NumericRange.Inclusive[Long]
@@ -165,10 +160,6 @@ def unary_+: Int
 def unary_-: Int
 def unary_~: Int
 def underlying(): AnyRef
-def until(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]]
-def until(end: Double,step: Double): scala.collection.immutable.NumericRange.Exclusive[Double]
-def until(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]]
-def until(end: Float,step: Float): scala.collection.immutable.NumericRange.Exclusive[Float]
 def until(end: Int): scala.collection.immutable.Range
 def until(end: Int,step: Int): scala.collection.immutable.Range
 def until(end: Long): scala.collection.immutable.NumericRange.Exclusive[Long]

test/files/presentation/infix-completion2.check

@@ -3,8 +3,7 @@ reload: Snippet.scala
 askTypeCompletion at Snippet.scala(1,34)
 ================================================================================
 [response] askTypeCompletion at (1,34)
-retrieved 211 members
-[inaccessible] protected def integralNum: math.Numeric.DoubleAsIfIntegral.type
+retrieved 202 members
 [inaccessible] protected def num: math.Numeric.DoubleIsFractional.type
 [inaccessible] protected def ord: math.Ordering.Double.type
 [inaccessible] protected def unifiedPrimitiveEquals(x: Any): Boolean
@@ -140,10 +139,6 @@ def isValidLong: Boolean
 def longValue(): Long
 def round: Long
 def shortValue(): Short
-def to(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]]
-def to(end: Double,step: Double): scala.collection.immutable.NumericRange.Inclusive[Double]
-def to(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]]
-def to(end: Float,step: Float): scala.collection.immutable.NumericRange.Inclusive[Float]
 def to(end: Int): scala.collection.immutable.Range.Inclusive
 def to(end: Int,step: Int): scala.collection.immutable.Range.Inclusive
 def to(end: Long): scala.collection.immutable.NumericRange.Inclusive[Long]
@@ -165,10 +160,6 @@ def unary_+: Int
 def unary_-: Int
 def unary_~: Int
 def underlying(): AnyRef
-def until(end: Double): Range.Partial[Double,scala.collection.immutable.NumericRange[Double]]
-def until(end: Double,step: Double): scala.collection.immutable.NumericRange.Exclusive[Double]
-def until(end: Float): Range.Partial[Float,scala.collection.immutable.NumericRange[Float]]
-def until(end: Float,step: Float): scala.collection.immutable.NumericRange.Exclusive[Float]
 def until(end: Int): scala.collection.immutable.Range
 def until(end: Int,step: Int): scala.collection.immutable.Range
 def until(end: Long): scala.collection.immutable.NumericRange.Exclusive[Long]

test/files/run/range.scala

@@ -54,14 +54,12 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     implicit val imp1 = Numeric.BigDecimalAsIfIntegral
-    implicit val imp2 = Numeric.DoubleAsIfIntegral
 
     val _grs = List[GR[_]](
       GR(BigDecimal(5.0)),
       GR(BigDecimal(0.25)),  // scala/bug#9348
       GR(BigInt(5)),
       GR(5L),
-      GR(5.0d),
       GR(2.toByte)
     )
     val grs = _grs ::: (_grs map (_.negated))

test/files/run/t3518.scala

@@ -21,14 +21,6 @@ object Test {
     val descending = sz to 1 by -1
     check { assert(descending.min == 1) }
     check { assert(descending.max == sz) }
-
-    val numeric = 1.0 to sz.toDouble by 1
-    check { assert(numeric.min == 1.0) }
-    check { assert(numeric.max == sz.toDouble) }
-
-    val numdesc = sz.toDouble to 1.0 by -1
-    check { assert(numdesc.min == 1.0) }
-    check { assert(numdesc.max == sz.toDouble) }
   }
 
   def check[U](b: =>U) {

test/files/run/t4201.scala

@@ -8,7 +8,5 @@ empty Range 100 until 100
 NumericRange 1 to 10
 NumericRange 1 to 10 by 2
 NumericRange 0.1 until 1.0 by 0.1
-NumericRange 0.1 until 1.0 by 0.1
-NumericRange 0.1 until 1.0 by 0.1 (using NumericRange 0.1 until 1.0 by 0.1 of BigDecimal)
 NumericRange 0 days until 10 seconds by 1 second
 empty NumericRange 0 days until 0 days by 1 second

test/files/run/t5857.scala

@@ -13,10 +13,8 @@ object Test extends App {
   println(1L to 10L)
   println(1L to 10L by 2)
 
-  // want to know if this is BigDecimal or Double stepping by BigDecimal
-  println(0.1 until 1.0 by 0.1)
+  // want to know if this is BigDecimal stepping by BigDecimal
   println(Range.BigDecimal(BigDecimal("0.1"), BigDecimal("1.0"), BigDecimal("0.1")))
-  println(Range.Double(0.1, 1.0, 0.1))
 
   import concurrent.duration.{SECONDS => Seconds, _}, collection.immutable.NumericRange
   implicit val `duration is integerish`: math.Integral[FiniteDuration] = new math.Integral[FiniteDuration] {

test/files/run/t9656.check

@@ -137,17 +137,6 @@ class RangeConsistencyTest {
     assert( (-3 to Int.MaxValue).dropWhile(_ <= 0).length == Int.MaxValue )
     assert( (-3 to Int.MaxValue).span(_ <= 0) match { case (a,b) => a.length == 4 && b.length == Int.MaxValue } )
   }
-  
-  @Test
-  def testSI9348() {
-    // Test exclusive range with (end-start) != 0 (mod step)
-    assert( (0.0f until 0.4f by 0.25f) sameElements List(0.0f, 0.25f) )
-    assert( (1.0 until 2.2 by 0.5) sameElements List(1.0, 1.5, 2.0) )
-    
-    def bd(d: Double) = BigDecimal(d)
-    val bdRange = bd(-10.0) until bd(0.0) by bd(4.5)
-    assert( bdRange sameElements List(bd(-10.0), bd(-5.5), bd(-1.0)) )
-  }
 
   @Test
   def test_SI9388()  {

test/files/run/t9656.scala

@@ -5,9 +5,6 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.JUnit4
 
-import scala.math.Numeric.FloatAsIfIntegral
-
-
 @RunWith(classOf[JUnit4])
 class NumericTest {
 
@@ -17,22 +14,6 @@ class NumericTest {
     assertTrue(-0.0.abs equals 0.0)
     assertTrue(-0.0f.abs equals 0.0f)
   }
-  
-  /* Test for scala/bug#9348 */
-  @Test
-  def testFloatAsIfIntegral {
-    val num = scala.math.Numeric.FloatAsIfIntegral
-    assertTrue(num.quot(1.0f, 0.5f) equals 2.0f)
-    assertTrue(num.quot(1.0f, 0.3f) equals 3.0f)
-  }
-
-  /* Test for scala/bug#9348 */
-  @Test
-  def testDoubleAsIfIntegral {
-    val num = scala.math.Numeric.DoubleAsIfIntegral
-    assertTrue(num.quot(1.0, 0.25) equals 4.0)
-    assertTrue(num.quot(0.5, 0.15) equals 3.0)
-  }
 
   /* Test for scala/bug#9348 */
   @Test