如何为所有数字类型创建一个通用类？

Question

我正在尝试创建一个对所有数字类型通用的 Vector 类。 我最初的尝试是为所有类型编写一个类，如下所示：

class Vector3f(val x:Float, val y:Float, val z:Float)

由于 scala 支持专门的注释，我可以使用它为所有数字类型生成这些类

class Vector3[A <: What?](val x:A,val y:A, val z:A)

，但我发现作为数字超级类型的所有内容都是 AnyVal，但 AnyVal 不是支持+-*/。那么，在不牺牲未装箱数字类型性能的情况下执行此操作的正确方法是什么？

Answer 1

你不能。现在不行。也许什么时候，如果，Numeric 变得专业化。

假设您获得了最简单的参数化类：

class Vector3[@specialized T](val x: T, val y: T, val z: T)(implicit num: Numeric[T]) {
    def +(other: Vector3[T]) = new Vector3(num.plus(x, other.x), num.plus(y, other.y), num.plus(z, other.z))
}

+ 方法将编译成大致如下所示的内容：

override <specialized> def +$mcD$sp(other: Vector3): Vector3 = new Vector3$mcD$sp(
  scala.Double.unbox(
    Vector3$mcD$sp.this.Vector3$num.plus(
      scala.Double.box(Vector3$mcD$sp.this.x()), 
      scala.Double.box(other.x$mcD$sp()))),
  scala.Double.unbox(
    Vector3$mcD$sp.this.Vector3$num.plus(
      scala.Double.box(Vector3$mcD$sp.this.y()),
      scala.Double.box(other.y$mcD$sp()))),
  scala.Double.unbox(
    Vector3$mcD$sp.this.Vector3$num.plus(
      scala.Double.box(Vector3$mcD$sp.this.z()), 
      scala.Double.box(other.z$mcD$sp()))), 
  Vector3$mcD$sp.this.Vector3$num);

这就是 scalac -optimize -Xprint:jvm 输出。现在，甚至每个专用类型都有子类，因此您可以在不装箱的情况下初始化 Vector3，但只要 Numeric 不是专用的，您就无法更进一步。

好吧...您可以编写自己的Numeric 并对其进行专门化，但是，在这一点上，我不确定通过首先对类进行参数化您会获得什么。

Answer 2

简短的回答是：您无法获得全部性能。或者至少我还没有找到任何可以提供充分性能的东西。 （我已经在这个用例中尝试了一段时间；我放弃了并编写了一个代码生成器，特别是因为你也不能一般地处理不同的向量大小。）

我很高兴以其他方式显示，但到目前为止，我尝试过的所有操作都在运行时间上有小幅（30％）到大幅（900％）的增加。

---

编辑：这是一个显示我的意思的测试。

object Specs {
  def ptime[T](f: => T): T = {
    val t0 = System.nanoTime
    val ans = f
    printf("Elapsed: %.3f s\n",(System.nanoTime-t0)*1e-9)
    ans
  }
  def lots[T](n: Int, f: => T): T = if (n>1) { f; lots(n-1,f) } else f

  sealed abstract class SpecNum[@specialized(Int,Double) T] {
    def plus(a: T, b: T): T
  }

  implicit object SpecInt extends SpecNum[Int] {
    def plus(a: Int, b: Int) = a + b
  }

  final class Vek[@specialized(Int,Double) T](val x: T, val y: T) {
    def +(v: Vek[T])(implicit ev: SpecNum[T]) = new Vek[T](ev.plus(x,v.x), ev.plus(y,v.y))
  }

  final class Uek[@specialized(Int,Double) T](var x: T, var y: T) {
    def +=(u: Uek[T])(implicit ev: SpecNum[T]) = { x = ev.plus(x,u.x); y = ev.plus(y,u.y); this }
  }

  final class Veq(val x: Int, val y: Int) {
    def +(v: Veq) = new Veq(x + v.x, y + v.y)
  }

  final class Ueq(var x: Int, var y: Int) {
    def +=(u: Ueq) = { x += u.x; y += u.y; this }
  }

  def main(args: Array[String]) {
    for (i <- 1 to 6) {
      ptime(lots(1000000,{val v = new Vek[Int](3,5); var u = new Vek[Int](0,0); var i=0; while (i<100) { u = (u+v); i += 1 }; u}))
      ptime(lots(1000000,{val v = new Veq(3,5); var u = new Veq(0,0); var i=0; while (i<100) { u = (u+v); i += 1 }; u}))
      ptime(lots(1000000,{val v = new Uek[Int](3,5); val u = new Uek[Int](0,0); var i=0; while (i<100) { u += v; i += 1 }; u}))
      ptime(lots(1000000,{val v = new Ueq(3,5); val u = new Ueq(0,0); var i=0; while (i<100) { u += v; i += 1 }; u}))
    }
  }
}

和输出：

Elapsed: 0.939 s
Elapsed: 0.535 s
Elapsed: 0.077 s
Elapsed: 0.075 s
Elapsed: 0.947 s
Elapsed: 0.352 s
Elapsed: 0.064 s
Elapsed: 0.063 s
Elapsed: 0.804 s
Elapsed: 0.360 s
Elapsed: 0.064 s
Elapsed: 0.062 s
Elapsed: 0.521 s  <- Immutable specialized with custom numeric
Elapsed: 0.364 s  <- Immutable primitive type
Elapsed: 0.065 s  <- Mutable specialized with custom numeric
Elapsed: 0.065 s  <- Mutable primitive type
...

Answer 3

您可能想使用此处描述的类型类模式： http ://dcsobral.blogspot.com/2010/06/implicit-tricks-type-class-pattern.html

或者，您可以通过使用数字特征 http://www.scala-lang.org/api/current/scala/math/Numeric.html