Scala 在对Double执行算术时，如何覆盖NaN或无穷大结果？

我正在计算一组数字和一些结果 其中的计算返回

NaN

或

无穷大的结果
经过调查，我发现根本原因是
下面是算术除法：

object doublefun {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  val d1 = 0.0                                    //> d1  : Double = 0.0
  val d2 = 0.0                                    //> d2  : Double = 0.0

  val d = d1/d2                                   //> d  : Double = NaN

  val i1 = 1.0                                    //> i1  : Double = 1.0
  val i2 = 0.0                                    //> i2  : Double = 0.0

  val i = i1/i2                                   //> i  : Double = Infinity

  val o1 = 0                                      //> o1  : Int = 0
  val o2 = 0                                      //> o2  : Int = 0
  val o = o1/o2                                   //> java.lang.ArithmeticException: / by zero
}

我认为询问在这些情况下为什么返回
NaN
和
Infinity
，更像是一个问题
数学问题，但有趣的是，
0/0
抛出一个
算术异常
而
0.0/0.0
没有

我使用这些计算的结果执行降序排序：
NaN
&
Infinity
当我要求元素最后出现时，结果是元素首先出现

对于任何返回
NaN
或
无穷大的计算，我如何确保
它在排序时最后出现？我是否可以检查的结果中是否有
NaN
或
Infinity
计算，如果满足，只需分配到
0.0
：

if(d == Double.Infinity || d == Double.NaN){
  return 0.0
}

使用
NaN
而非例外的原因实际上是一个更一般的问题，在中进行了解释

不清楚您是如何进行排序的，但默认情况下正无穷大和负无穷大的排序顺序正确，
NaN
排在最后（升序）：

任何修改行为的简单方法都是在排序之前映射并匹配列表

val list = List(Double.PositiveInfinity, Double.NegativeInfinity, Double.NaN, 0.0, -1.0, 2.0)

list.map {
    case d if(d.isNaN) => 0.0 // Or whatever value you'd prefer.
    case d if(d.isNegInfinity) => 0.0 // Or whatever value you'd prefer.
    case d if(d.isPosInfinity) => 0.0 // Or whatever value you'd prefer.
    case d => d
}

按照升序，
Double.NegativeInfinity
首先出现，然后是所有升序实数，然后是
Double.PositiveInfinity
，然后是
NaN
。如果您希望
PositiveInfinity
和
NegativeInfinity
以及
NaN
以降序排在最后，那么您可以将它们全部映射到
Double。NegativeInfinity
您不能用这种方式检查NaN，因为（NaN==NaN）返回false（！！！）使用
isNaN
和
isInfinite
。您还可以参考
val list = List(Double.PositiveInfinity, Double.NegativeInfinity, Double.NaN, 0.0, -1.0, 2.0)

list.map {
    case d if(d.isNaN) => 0.0 // Or whatever value you'd prefer.
    case d if(d.isNegInfinity) => 0.0 // Or whatever value you'd prefer.
    case d if(d.isPosInfinity) => 0.0 // Or whatever value you'd prefer.
    case d => d
}