scala - 比较两个数字

Question

如何比较两个数字。任何数字。喜欢Int和Float？我对与复数或类似的东西进行比较不感兴趣。我只想比较那些具有可比性的。Float 和 Int 是。

假设你有：

def compareTwoNumbers[???](array:Array[???], number:???) = {
    array(0) > number // this has to compile
}

我写什么而不是???？

到目前为止我尝试过的事情：

1. Number.
2. T <: Number
3. Numeric（对不起，我不明白在这种情况下如何使用它，没有示例/文档太差了）。

Answer 1

只需使用排序类型类：

def cmp[A](arr: Array[A], number: A)(implicit ord: Ordering[A]) =
  ord.gt(arr(0), number)

// or

def cmp[A](arr: Array[A], number: A)(implicit ord: Ordering[A]) = {
  import ord._
  arr(0) > number
}

scala> cmp(Array(4), 2)
res9: Boolean = true

scala> cmp(Array(BigInt(4)), BigInt(2))
res15: Boolean = true

scala> cmp(Array(4), 2.0)
<console>:9: error: type mismatch;
 found   : Array[Int]
 required: Array[AnyVal]

scala> cmp(Array(4.0), 2)
<console>:9: error: type mismatch;
 found   : Array[Double]
 required: Array[AnyVal]

Answer 2

我认为主要问题是数字类型的转换。所以让我们编码：

trait NumericConversion[X, Y] {
  def convert(x: X): Y
}

当然，必须指定那个抽象概念：（例如）

implicit object Int2IntNumericConversion extends NumericConversion[Int, Int] {
  def convert(i: Int): Int = i
}
implicit object Double2DoubleNumericConversion extends NumericConversion[Double, Double] {
  def convert(d: Double): Double = d
}
implicit object Int2DoubleNumericConversion extends NumericConversion[Int, Double] {
  def convert(i: Int): Double = i.toDouble
}

现在比较方法如下：

def compareTwoNumbers1[N1, N2, N3](n1: N1, n2: N2)
                                  (implicit conv1: NumericConversion[N1, N3], 
                                            conv2: NumericConversion[N2, N3], 
                                              ord: Ordering[N3]): Int = {
  ord compare (conv1 convert n1, conv2 convert n2)
}

用法：

compareTwoNumbers1[Int, Double, Double](3, 8D)  // -1

可惜了，我们必须显式声明类型参数，所以我尝试了：

def compareTwoNumbers2[N3] = new {
  def apply[N1, N2](n1: N1, n2: N2)(implicit conv1: NumericConversion[N1, N3],
                                             conv2: NumericConversion[N2, N3], 
                                               ord: Ordering[N3]): Int = {
    ord compare (conv1 convert n1, conv2 convert n2)
  }
}

这简化为一种类型的参数：

compareTwoNumbers2[Double](3, 8D)  // -1

不满意，所以我尝试了这个：

trait NumericUpperBound[Num1, Num2, UpperBound]
implicit object NumericUpperBoundIDD extends NumericUpperBound[Int, Double, Double]
implicit object NumericUpperBoundDID extends NumericUpperBound[Double, Int, Double]

使用新的比较方法：

def compareTwoNumbers3[N1, N2, N3](n1: N1, n2: N2)
                                 (implicit nub: NumericUpperBound[N1, N2, N3], 
                                         conv1: NumericConversion[N1, N3], 
                                         conv2: NumericConversion[N2, N3], 
                                           ord: Ordering[N3]): Int = {
  ord compare (conv1 convert n1, conv2 convert n2)
}

现在它起作用了：

compareTwoNumbers3(3, 8D)  // -1

当然，必须为所有原语创建类型类。但是稍后将其扩展到BigInt等是灵活的。

编辑

@wvxvw 的评论提到了一个矩阵，它NumericUpperBounds启发了我绕过矩阵，这是一个运行示例（暂时不包括在内）Byte：Short

trait ==>[X, Y] extends (X => Y)

object ==> {
  def apply[X, Y](f: X => Y): X ==> Y = {
    new (X ==> Y) {
      def apply(x: X): Y = f(x)
    }
  }
}

implicit val Int2LongNumericConversion = ==> { x: Int => x.toLong }
implicit val Int2FloatNumericConversion = ==> { x: Int => x.toFloat }
implicit val Int2DoubleNumericConversion = ==> { x: Int => x.toDouble }
implicit val Long2FloatNumericConversion = ==> { x: Long => x.toFloat }
implicit val Long2DoubleNumericConversion = ==> { x: Long => x.toDouble }
implicit val Float2DoubleNumericConversion = ==> { x: Float => x.toDouble }
implicit def reflexiveNumericConversion[X]: X ==> X = new (X ==> X) { def apply(x: X): X = x }

trait NumericUpperBound[Num1, Num2, UpperBound]

implicit def reflexiveNumericUpperBound[X]: NumericUpperBound[X, X, X] = new NumericUpperBound[X, X, X] {}
implicit def inductiveNumericUpperBound1[X, Y](implicit ev: X ==> Y): NumericUpperBound[Y, X, Y] = new NumericUpperBound[Y, X, Y] {}
implicit def inductiveNumericUpperBound2[X, Y](implicit ev: X ==> Y): NumericUpperBound[X, Y, Y] = new NumericUpperBound[X, Y, Y] {}

def compareTwoNumbers[N1, N2, N3](n1: N1, n2: N2)
                                 (implicit nub: NumericUpperBound[N1, N2, N3], 
                                         conv1: N1 ==> N3, 
                                         conv2: N2 ==> N3, 
                                           ord: Ordering[N3]): Int = {
  ord compare (n1, n2)
}

compareTwoNumbers(9L, 13) // -1

Answer 3

我目前正在学习 Scala，所以不要太认真地回答我的问题，但我认为View Bounds或Type Constraints可以帮助你。View Bound 允许您比较任何标准数字，因为它们之间存在隐式视图，但它不会更进一步，因为没有从 BigInt 到 BigDecimal 的隐式视图。

def compareTwoNumbers[A <% Double, B <% Double](array:Array[A], number:B) = array(0) > number

scala> compareTwoNumbers(Array(1, 2, 0), 0.99)
res1: Boolean = true

scala> compareTwoNumbers(Array(1.0, 2, 0), 0.99)
res2: Boolean = true

scala> compareTwoNumbers(Array(1.0, 2, 0), 1)
res3: Boolean = false

我很想知道是否可以支持 BigInt 和 BigDecimal，并想知道我的解决方案有哪些缺点。

Answer 4

这里是：

def cmp[T1, T2](arr: Array[T1], num: T2)
       (implicit v12: T1 => T2 = null, v21: T2 => T1 = null,
        ord1: Ordering[T1], ord2: Ordering[T2]): Boolean = v12 match {
    case null => ord1.gt(arr(0), num)
    case _    => ord2.gt(arr(0), num)
  }

一些用例：

scala> cmp(Array(1,2), 0.1)  //T1 = Int, T2 = Double 
res3: Boolean = true

scala> cmp(Array(1.2, 2.3), 1) //T1 = Double, T2 = Int 
res4: Boolean = true

scala> cmp(Array(1,2), BigInt(100))  //T1 = Int, T2 = BigInt 
res5: Boolean = false

scala> cmp(Array(123.5 ,2233.9), BigDecimal(100)) //T1 = Double, T2 = BigDecimal 
res6: Boolean = true

scala> cmp(Array(123.5 ,2233.9), 200.toByte) 
res7: Boolean = true

Answer 5

def compareTwoNumbers(a: Number, b: Number) = {
  a.floatValue() > b.floatValue() // this has to compile
}

Answer 6

采用这段代码并不难：

def gt[A : Numeric, B: Numeric](first: A, second: B) = {
    val a = implicitly[Numeric[A]].toDouble(first)
    val b = implicitly[Numeric[B]].toDouble(second)
    a > b
}

应该使用不同类型的数字：

scala> gt(4, 4.0)
res3: Boolean = false

scala> gt(4, 3.0)
res4: Boolean = true

scala> gt(3L, 4.0)
res5: Boolean = false