स्कैला: जेनेरिक क्लास प्रकार

Question

पर बाधा मैं स्कैला के लिए बहुत नया हूं।

मैं एक जेनेरिक मैट्रिक्स क्लास "क्लास मैट्रिक्स [टी]" को कार्यान्वित करना चाहता हूं। टी पर एकमात्र बाधा यह होनी चाहिए कि टी को "+" और "*" मोथोड/फ़ंक्शन लागू करना चाहिए। मैं यह कार्य कैसे करूं?

उदाहरण के लिए मैं Int, Double, और अपने स्वयं के परिभाषित प्रकारों का उपयोग करने में सक्षम होना चाहता हूं उदा। परिसर

मैं पंक्तियों के साथ कुछ सोच रहा था:

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 
} 

सब कुछ प्रकार की जाँच करता लेकिन मैं अभी भी एक मैट्रिक्स का दृष्टांत नहीं कर सकते। क्या मैं एक अंतर्निहित निर्माता हूं? मैं इसे बनाने के बारे में कैसे जाउंगा? या मैं अपनी विधि के बारे में पूरी तरह से गलत हूँ?

अग्रिम Troels

Answer 1

अंत में जवाब मिल गया :-) मुझे लगता है कि मैं अपने पहले प्रयास में बंद है कि अब तक नहीं था । यहाँ यह जाता है: (स्केला 2.8 के लिए लिखा)

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) 

Answer 2

धन्यवाद आप उस के लिए स्काला 2.8 के लिए Numeric उपयोग कर सकते हैं। यह here का वर्णन करता है। यह MatrixElement और इसके कार्यान्वयन की जगह लेंगे:

class Matrix[T : Numeric](data: Array[Array[T]]) { 
    def *(that: Matrix[T]) = // 
} 

Answer 3

यहाँ है 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 
    } 
}