From 37d3bcd49555f1e07992aa0a8d11befa1ed5de9a Mon Sep 17 00:00:00 2001
From: Brendan Zabarauskas <bjzaba@yahoo.com.au>
Date: Wed, 14 Nov 2012 10:20:36 +1000
Subject: [PATCH] Inherit Neg and move neg method into appropriate impls

---
 src/matrix.rs     | 42 ++++++++++++++++++------------------------
 src/quaternion.rs | 14 ++++++--------
 src/vector.rs     | 38 ++++++++++++++++----------------------
 3 files changed, 40 insertions(+), 54 deletions(-)

diff --git a/src/matrix.rs b/src/matrix.rs
index dc350dc..ce2a5e7 100644
--- a/src/matrix.rs
+++ b/src/matrix.rs
@@ -51,7 +51,7 @@ pub trait Matrix<T, ColVec, RowVec>: Eq, Index<uint, T>, ToPtr<T> {
     pure fn row(i: uint) -> RowVec;
 }
 
-pub trait NumericMatrix<T, ColVec, RowVec>: Matrix<T, ColVec, RowVec> {
+pub trait NumericMatrix<T, ColVec, RowVec>: Matrix<T, ColVec, RowVec>, Neg<self> {
     pure fn mul_t(value: T) -> self;
     pure fn mul_v(other: &ColVec) -> ColVec;
 }
@@ -158,6 +158,11 @@ pub impl<T:Copy> Mat2<T>: Matrix<T, Vec2<T>, Vec2<T>> {
 }
 
 pub impl<T:Copy Num NumCast> Mat2<T>: NumericMatrix<T, Vec2<T>, Vec2<T>> {
+    #[inline(always)]
+    pure fn neg() -> Mat2<T> {
+        Mat2::from_cols(-self[0], -self[1])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Mat2<T> {
         Mat2::from_cols(self[0].mul_t(value),
@@ -264,13 +269,6 @@ pub impl<T:Copy> Mat2<T>: Index<uint, Vec2<T>> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Mat2<T>: Neg<Mat2<T>> {
-    #[inline(always)]
-    pure fn neg() -> Mat2<T> {
-        Mat2::from_cols(-self[0], -self[1])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Mat2<T>: Eq {
     #[inline(always)]
@@ -394,7 +392,12 @@ pub impl<T:Copy> Mat3<T>: Matrix<T, Vec3<T>, Vec3<T>> {
     }
 }
 
-pub impl<T:Copy Num NumCast> Mat3<T>: NumericMatrix<T, Vec3<T>, Vec3<T>> {
+pub impl<T:Copy Num> Mat3<T>: NumericMatrix<T, Vec3<T>, Vec3<T>> {
+    #[inline(always)]
+    pure fn neg() -> Mat3<T> {
+        Mat3::from_cols(-self[0], -self[1], -self[2])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Mat3<T> {
         Mat3::from_cols(self[0].mul_t(value),
@@ -559,13 +562,6 @@ pub impl<T:Copy> Mat3<T>: Index<uint, Vec3<T>> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Mat3<T>: Neg<Mat3<T>> {
-    #[inline(always)]
-    pure fn neg() -> Mat3<T> {
-        Mat3::from_cols(-self[0], -self[1], -self[2])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Mat3<T>: Eq {
     #[inline(always)]
@@ -710,7 +706,12 @@ pub impl<T:Copy> Mat4<T>: Matrix<T, Vec4<T>, Vec4<T>> {
 
 }
 
-pub impl<T:Copy Num NumCast FuzzyEq> Mat4<T>: NumericMatrix<T, Vec4<T>, Vec4<T>> {
+pub impl<T:Copy Num> Mat4<T>: NumericMatrix<T, Vec4<T>, Vec4<T>> {
+    #[inline(always)]
+    pure fn neg() -> Mat4<T> {
+        Mat4::from_cols(-self[0], -self[1], -self[2], -self[3])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Mat4<T> {
         Mat4::from_cols(self[0].mul_t(value),
@@ -905,13 +906,6 @@ pub impl<T:Copy> Mat4<T>: Index<uint, Vec4<T>> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Mat4<T>: Neg<Mat4<T>> {
-    #[inline(always)]
-    pure fn neg() -> Mat4<T> {
-        Mat4::from_cols(-self[0], -self[1], -self[2], -self[3])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Mat4<T>: Eq {
     #[inline(always)]
diff --git a/src/quaternion.rs b/src/quaternion.rs
index 5622dbf..14352ba 100644
--- a/src/quaternion.rs
+++ b/src/quaternion.rs
@@ -23,7 +23,7 @@ pub type dquat4 = Quat<f64>;         /// a double-precision floating-point quate
 //
 //  Quaternion
 //
-pub trait Quaternion<T>: Eq, Index<uint, T>, ToPtr<T> {
+pub trait Quaternion<T>: Eq, Index<uint, T>, Neg<self>, ToPtr<T> {
     pure fn dim() -> uint;
     
     pure fn mul_t(value: T) -> self;
@@ -95,6 +95,11 @@ pub impl<T:Copy Num NumCast Trig Exp Extent Ord FuzzyEq> Quat<T>: Quaternion<T>
     #[inline(always)]
     pure fn dim() -> uint { 4 }
     
+    #[inline(always)]
+    pure fn neg() -> Quat<T> {
+        Quat::new(-self[0], -self[1], -self[2], -self[3])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Quat<T> {
         Quat::new(self[0] * value,
@@ -263,13 +268,6 @@ pub impl<T:Copy> Quat<T>: Index<uint, T> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Quat<T>: Neg<Quat<T>> {
-    #[inline(always)]
-    pure fn neg() -> Quat<T> {
-        Quat::new(-self[0], -self[1], -self[2], -self[3])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Quat<T>: Eq {
     #[inline(always)]
diff --git a/src/vector.rs b/src/vector.rs
index 04fb5a6..18eff52 100644
--- a/src/vector.rs
+++ b/src/vector.rs
@@ -35,7 +35,7 @@ pub trait Vector<T>: Eq, Index<uint, T>, ToPtr<T> {
     static pure fn dim() -> uint;
 }
 
-pub trait NumericVector<T>: Vector<T> {
+pub trait NumericVector<T>: Vector<T>, Neg<self>{
     pure fn mul_t(value: T) -> self;
     pure fn div_t(value: T) -> self;
     
@@ -123,6 +123,11 @@ pub impl<T> Vec2<T>: Vector<T> {
 }
     
 pub impl<T:Copy Num> Vec2<T>: NumericVector<T> {
+    #[inline(always)]
+    pure fn neg() -> Vec2<T> {
+        Vec2::new(-self[0], -self[1])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Vec2<T> {
         Vec2::new(self[0] * value,
@@ -189,13 +194,6 @@ pub impl<T:Copy> Vec2<T>: Index<uint, T> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Vec2<T>: Neg<Vec2<T>> {
-    #[inline(always)]
-    pure fn neg() -> Vec2<T> {
-        Vec2::new(-self[0], -self[1])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Vec2<T>: Eq {
     #[inline(always)]
@@ -303,6 +301,11 @@ pub impl<T> Vec3<T>: Vector<T> {
 }
 
 pub impl<T:Copy Num> Vec3<T>: NumericVector<T> {
+    #[inline(always)]
+    pure fn neg() -> Vec3<T> {
+        Vec3::new(-self[0], -self[1], -self[2])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Vec3<T> {
         Vec3::new(self[0] * value,
@@ -375,13 +378,6 @@ pub impl<T:Copy> Vec3<T>: Index<uint, T> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Vec3<T>: Neg<Vec3<T>> {
-    #[inline(always)]
-    pure fn neg() -> Vec3<T> {
-        Vec3::new(-self[0], -self[1], -self[2])
-    }
-}
-
 // TODO: make work for T:Integer
 pub impl<T:Copy FuzzyEq> Vec3<T>: Eq {
     #[inline(always)]
@@ -489,6 +485,11 @@ pub impl<T> Vec4<T>: Vector<T> {
 }
 
 pub impl<T:Copy Num> Vec4<T>: NumericVector<T> {
+    #[inline(always)]
+    pure fn neg() -> Vec4<T> {
+        Vec4::new(-self[0], -self[1], -self[2], -self[3])
+    }
+    
     #[inline(always)]
     pure fn mul_t(value: T) -> Vec4<T> {
         Vec4::new(self[0] * value,
@@ -567,13 +568,6 @@ pub impl<T:Copy> Vec4<T>: Index<uint, T> {
     }
 }
 
-pub impl<T:Copy Neg<T>> Vec4<T>: Neg<Vec4<T>> {
-    #[inline(always)]
-    pure fn neg() -> Vec4<T> {
-        Vec4::new(-self[0], -self[1], -self[2], -self[3])
-    }
-}
-
 pub impl<T:Copy FuzzyEq> Vec4<T>: Eq {
     #[inline(always)]
     pure fn eq(other: &Vec4<T>) -> bool {