Generics Scala:泛型类类型的约束
我对斯卡拉很陌生 我想实现一个通用的矩阵类“classmatrix[T]”。对T的唯一限制应该是T应该实现一个“+”和一个“*”方法/函数。我该怎么做呢 例如,我希望能够同时使用Int、Double和我自己定义的类型,例如Complex 我在想一些大致的事情:Generics Scala:泛型类类型的约束,generics,scala,scala-2.8,Generics,Scala,Scala 2.8,我对斯卡拉很陌生 我想实现一个通用的矩阵类“classmatrix[T]”。对T的唯一限制应该是T应该实现一个“+”和一个“*”方法/函数。我该怎么做呢 例如,我希望能够同时使用Int、Double和我自己定义的类型,例如Complex 我在想一些大致的事情: class Matrix[T <: MatrixElement[T]](data: Array[Array[T]]) { def *(that: Matrix) = ..// code that uses "+" and "*
class Matrix[T <: MatrixElement[T]](data: Array[Array[T]]) {
def *(that: Matrix) = ..// code that uses "+" and "*" on the elements
}
abstract class MatrixElement[T] {
def +(that: T): T
def *(that: T): T
}
implicit object DoubleMatrixElement extends MatrixElement[Double]{
def +(that: Double): Double = this + that
def *(that: Double): Double = this * that
}
implicit object ComplexMatrixElement extends MatrixElement[Complex]{
def +(that: Complex): Complex = this + that
def *(that: Complex): Complex = this * that
}
class Matrix[T您可以将其用于Scala 2.8。描述如下。它将取代MatrixElement及其实现:
class Matrix[T : Numeric](data: Array[Array[T]]) {
def *(that: Matrix[T]) = //
}
以下是Numeric
解决方案的外观:
// ': Numeric[T]' adds an implicit parameter to the constructor,
// which allows T to be used in arithmetic expressions.
class Matrix[T: Numeric](val data: Array[Array[T]]) {
def *(that: Matrix[T]) = {
val nt = implicitly[Numeric[T]]
import nt._ // This imports an Implicit View to allow operator syntax
this.data(0)(0) * that.data(0)(0)
// etc
}
}
终于找到了答案:-)我想我第一次尝试的时候并没有那么远。
下面是:(为scala 2.8编写)
T:Numeric[T]
应该是T:Numeric
。你写这篇文章时没有回复吗?:-)我考虑过Numeric。但我真的不知道这对我自己的类型(如Complex)会有什么影响。我认为Complex需要扩展Numeric。首先,这需要我实现更多的方法,而不仅仅是+和*。在这些排序中,如据我所知,对复数没有严格的排序。关键是我需要矩阵来处理任何类型,只要完全填充方法+和*就可以实现。如果你只需要+和*,就可以实现很多方法。但是你仍然可以用这两个方法来创建类似于数值的东西。这应该是两个工作量很大的工作(如果值得的话,可以稍后返回并用数值替换。)@troels您可以始终按实际部分排序,或者对于所有比较只返回“0”。并且您可以始终使用错误(“未定义的方法”)来“实现”方法
。但是请注意,Complex
不会扩展Numeric
。相反,会有一个Numeric[Complex]
的实例。如何实现Numeric[T]的子类型?我一直在寻找这方面的指南,但没有找到任何指南。另外,还将其作为一个单独的问题发布:
trait MatrixElement[T] {
def +(that: T): T
def *(that: T): T
}
object MatrixElement {
implicit def intToMatrixElement(x : Int) = new MatrixElement[Int] {
def +(y : Int) = x + y
def *(y : Int) = x * y
}
implicit def doubleToMatrixElement(x : Double) = new MatrixElement[Double] {
def +(y : Double) = x + y
def *(y : Double) = x * y
}
implicit def complexToMatrixElement(x : Complex) = new MatrixElement[Complex] {
def +(y : Complex) = x + y
def *(y : Complex) = x * y
}
}
class Matrix[T <% MatrixElement[T] : ClassManifest ](d: Array[Array[T]]) {
def *(that: Matrix) = ..// code that uses "+" and "*" on the elements
}
scala> new Matrix(Array(Array(1,0),Array(0,1)))
res0: Matrix[Int] =
1 0
0 1
scala> new Matrix(Array(Array(new Complex(0),new Complex(1)),Array(new Complex(1),new Complex(0))))
res9: Matrix[Complex] =
(0.0,0.0i) (1.0,0.0i)
(1.0,0.0i) (0.0,0.0i)