diff --git a/src/mat.rs b/src/mat.rs
index 0058f12..64d6afc 100644
--- a/src/mat.rs
+++ b/src/mat.rs
@@ -1,8 +1,7 @@
-use core::cast::transmute;
-use core::cmp::ApproxEq;
-use core::num::Zero::zero;
-use core::num::One::one;
-use core::util;
+use std::cast::transmute;
+use std::cmp::ApproxEq;
+use std::num::{Zero, One};
+use std::util;
 
 use vec::*;
 use quat::Quat;
@@ -343,8 +342,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
      */
     #[inline(always)]
     fn from_value(value: T) -> Mat2<T> {
-        BaseMat2::new(value, zero(),
-                      zero(), value)
+        BaseMat2::new(value, Zero::zero(),
+                      Zero::zero(), value)
     }
 
     /**
@@ -360,8 +359,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
      */
     #[inline(always)]
     fn identity() -> Mat2<T> {
-        BaseMat2::new( one::<T>(), zero::<T>(),
-                      zero::<T>(),  one::<T>())
+        BaseMat2::new(  One::one::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(),   One::one::<T>())
     }
 
     /**
@@ -377,8 +376,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
      */
     #[inline(always)]
     fn zero() -> Mat2<T> {
-        BaseMat2::new(zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>())
+        BaseMat2::new(Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>())
     }
 
     #[inline(always)]
@@ -426,7 +425,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
     #[inline(always)]
     fn inverse(&self) -> Option<Mat2<T>> {
         let d = self.determinant();
-        if d.approx_eq(&zero()) {
+        if d.approx_eq(&Zero::zero()) {
             None
         } else {
             Some(BaseMat2::new( self[1][1]/d, -self[0][1]/d,
@@ -515,8 +514,8 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
 
     #[inline(always)]
     fn is_diagonal(&self) -> bool {
-        self[0][1].approx_eq(&zero()) &&
-        self[1][0].approx_eq(&zero())
+        self[0][1].approx_eq(&Zero::zero()) &&
+        self[1][0].approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
@@ -532,7 +531,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec2<T>> for Mat2<T> {
 
     #[inline(always)]
     fn is_invertible(&self) -> bool {
-        !self.determinant().approx_eq(&zero())
+        !self.determinant().approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
@@ -612,9 +611,9 @@ impl<T:Copy + Float + NumAssign> BaseMat2<T, Vec2<T>> for Mat2<T> {
      */
     #[inline(always)]
     fn to_mat3(&self) -> Mat3<T> {
-        BaseMat3::new(self[0][0], self[0][1], zero(),
-                      self[1][0], self[1][1], zero(),
-                          zero(),     zero(),  one())
+        BaseMat3::new(  self[0][0],   self[0][1], Zero::zero(),
+                        self[1][0],   self[1][1], Zero::zero(),
+                      Zero::zero(), Zero::zero(),   One::one())
     }
 
     /**
@@ -634,10 +633,10 @@ impl<T:Copy + Float + NumAssign> BaseMat2<T, Vec2<T>> for Mat2<T> {
      */
     #[inline(always)]
     fn to_mat4(&self) -> Mat4<T> {
-        BaseMat4::new(self[0][0], self[0][1], zero(), zero(),
-                      self[1][0], self[1][1], zero(), zero(),
-                          zero(),     zero(),  one(), zero(),
-                          zero(),     zero(), zero(),  one())
+        BaseMat4::new(  self[0][0],   self[0][1], Zero::zero(), Zero::zero(),
+                        self[1][0],   self[1][1], Zero::zero(), Zero::zero(),
+                      Zero::zero(), Zero::zero(),   One::one(), Zero::zero(),
+                      Zero::zero(), Zero::zero(), Zero::zero(),   One::one())
     }
 }
 
@@ -720,9 +719,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
      */
     #[inline(always)]
     fn from_value(value: T) -> Mat3<T> {
-        BaseMat3::new(value, zero(), zero(),
-                      zero(), value, zero(),
-                      zero(), zero(), value)
+        BaseMat3::new(value, Zero::zero(), Zero::zero(),
+                      Zero::zero(), value, Zero::zero(),
+                      Zero::zero(), Zero::zero(), value)
     }
 
     /**
@@ -740,9 +739,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
      */
     #[inline(always)]
     fn identity() -> Mat3<T> {
-        BaseMat3::new( one::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(),  one::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(),  one::<T>())
+        BaseMat3::new(One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>())
     }
 
     /**
@@ -760,9 +759,9 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
      */
     #[inline(always)]
     fn zero() -> Mat3<T> {
-        BaseMat3::new(zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>())
+        BaseMat3::new(Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>())
     }
 
     #[inline(always)]
@@ -823,7 +822,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
     // #[inline(always)]
     fn inverse(&self) -> Option<Mat3<T>> {
         let d = self.determinant();
-        if d.approx_eq(&zero()) {
+        if d.approx_eq(&Zero::zero()) {
             None
         } else {
             let m: Mat3<T> = BaseMat3::from_cols(self[1].cross(&self[2]).div_t(d),
@@ -925,14 +924,14 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
 
     #[inline(always)]
     fn is_diagonal(&self) -> bool {
-        self[0][1].approx_eq(&zero()) &&
-        self[0][2].approx_eq(&zero()) &&
+        self[0][1].approx_eq(&Zero::zero()) &&
+        self[0][2].approx_eq(&Zero::zero()) &&
 
-        self[1][0].approx_eq(&zero()) &&
-        self[1][2].approx_eq(&zero()) &&
+        self[1][0].approx_eq(&Zero::zero()) &&
+        self[1][2].approx_eq(&Zero::zero()) &&
 
-        self[2][0].approx_eq(&zero()) &&
-        self[2][1].approx_eq(&zero())
+        self[2][0].approx_eq(&Zero::zero()) &&
+        self[2][1].approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
@@ -954,7 +953,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec3<T>> for Mat3<T> {
 
     #[inline(always)]
     fn is_invertible(&self) -> bool {
-        !self.determinant().approx_eq(&zero())
+        !self.determinant().approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
@@ -1027,9 +1026,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
         let cos_theta = radians.cos();
         let sin_theta = radians.sin();
 
-        BaseMat3::new( one(),     zero(),    zero(),
-                      zero(),  cos_theta, sin_theta,
-                      zero(), -sin_theta, cos_theta)
+        BaseMat3::new(  One::one(), Zero::zero(), Zero::zero(),
+                      Zero::zero(),    cos_theta,    sin_theta,
+                      Zero::zero(),   -sin_theta,    cos_theta)
     }
 
     /**
@@ -1041,9 +1040,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
         let cos_theta = radians.cos();
         let sin_theta = radians.sin();
 
-        BaseMat3::new(cos_theta, zero(), -sin_theta,
-                         zero(),  one(),     zero(),
-                      sin_theta, zero(),  cos_theta)
+        BaseMat3::new(   cos_theta, Zero::zero(),   -sin_theta,
+                      Zero::zero(),   One::one(), Zero::zero(),
+                         sin_theta, Zero::zero(),    cos_theta)
     }
 
     /**
@@ -1055,9 +1054,9 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
         let cos_theta = radians.cos();
         let sin_theta = radians.sin();
 
-        BaseMat3::new( cos_theta, sin_theta, zero(),
-                      -sin_theta, cos_theta, zero(),
-                          zero(),    zero(),  one())
+        BaseMat3::new(   cos_theta,    sin_theta, Zero::zero(),
+                        -sin_theta,    cos_theta, Zero::zero(),
+                      Zero::zero(), Zero::zero(),   One::one())
     }
 
     /**
@@ -1091,15 +1090,15 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
     fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
         let c = radians.cos();
         let s = radians.sin();
-        let _1_c = one::<T>() - c;
+        let _1_c =  One::one::<T>() - c;
 
         let x = axis.x;
         let y = axis.y;
         let z = axis.z;
 
         BaseMat3::new(_1_c*x*x + c,   _1_c*x*y + s*z, _1_c*x*z - s*y,
-                    _1_c*x*y - s*z, _1_c*y*y + c,   _1_c*y*z + s*x,
-                    _1_c*x*z + s*y, _1_c*y*z - s*x, _1_c*z*z + c)
+                      _1_c*x*y - s*z, _1_c*y*y + c,   _1_c*y*z + s*x,
+                      _1_c*x*z + s*y, _1_c*y*z - s*x, _1_c*z*z + c)
     }
 
     #[inline(always)]
@@ -1133,10 +1132,10 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
      */
     #[inline(always)]
     fn to_mat4(&self) -> Mat4<T> {
-        BaseMat4::new(self[0][0], self[0][1], self[0][2], zero(),
-                      self[1][0], self[1][1], self[1][2], zero(),
-                      self[2][0], self[2][1], self[2][2], zero(),
-                          zero(),     zero(),     zero(),  one())
+        BaseMat4::new(  self[0][0],   self[0][1],   self[0][2], Zero::zero(),
+                        self[1][0],   self[1][1],   self[1][2], Zero::zero(),
+                        self[2][0],   self[2][1],   self[2][2], Zero::zero(),
+                      Zero::zero(), Zero::zero(), Zero::zero(),   One::one())
     }
 
     /**
@@ -1154,7 +1153,7 @@ impl<T:Copy + Float + NumAssign> BaseMat3<T, Vec3<T>> for Mat3<T> {
         let _1:   T = num::cast(1.0);
         let half: T = num::cast(0.5);
 
-        if trace >= zero() {
+        if trace >= Zero::zero() {
             s = (_1 + trace).sqrt();
             w = half * s;
             s = half / s;
@@ -1272,10 +1271,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
      */
     #[inline(always)]
     fn from_value(value: T) -> Mat4<T> {
-        BaseMat4::new(value, zero(), zero(), zero(),
-                      zero(), value, zero(), zero(),
-                      zero(), zero(), value, zero(),
-                      zero(), zero(), zero(), value)
+        BaseMat4::new(value, Zero::zero(), Zero::zero(), Zero::zero(),
+                      Zero::zero(), value, Zero::zero(), Zero::zero(),
+                      Zero::zero(), Zero::zero(), value, Zero::zero(),
+                      Zero::zero(), Zero::zero(), Zero::zero(), value)
     }
 
     /**
@@ -1295,10 +1294,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
      */
     #[inline(always)]
     fn identity() -> Mat4<T> {
-        BaseMat4::new( one::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(),  one::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(),  one::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>(),  one::<T>())
+        BaseMat4::new(One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), One::one::<T>())
     }
 
     /**
@@ -1318,10 +1317,10 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
      */
     #[inline(always)]
     fn zero() -> Mat4<T> {
-        BaseMat4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
-                      zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
+        BaseMat4::new(Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(),
+                      Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>(), Zero::zero::<T>())
     }
 
     #[inline(always)]
@@ -1410,7 +1409,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
 
     fn inverse(&self) -> Option<Mat4<T>> {
         let d = self.determinant();
-        if d.approx_eq(&zero()) {
+        if d.approx_eq(&Zero::zero()) {
             None
         } else {
 
@@ -1556,21 +1555,21 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
 
     #[inline(always)]
     fn is_diagonal(&self) -> bool {
-        self[0][1].approx_eq(&zero()) &&
-        self[0][2].approx_eq(&zero()) &&
-        self[0][3].approx_eq(&zero()) &&
+        self[0][1].approx_eq(&Zero::zero()) &&
+        self[0][2].approx_eq(&Zero::zero()) &&
+        self[0][3].approx_eq(&Zero::zero()) &&
 
-        self[1][0].approx_eq(&zero()) &&
-        self[1][2].approx_eq(&zero()) &&
-        self[1][3].approx_eq(&zero()) &&
+        self[1][0].approx_eq(&Zero::zero()) &&
+        self[1][2].approx_eq(&Zero::zero()) &&
+        self[1][3].approx_eq(&Zero::zero()) &&
 
-        self[2][0].approx_eq(&zero()) &&
-        self[2][1].approx_eq(&zero()) &&
-        self[2][3].approx_eq(&zero()) &&
+        self[2][0].approx_eq(&Zero::zero()) &&
+        self[2][1].approx_eq(&Zero::zero()) &&
+        self[2][3].approx_eq(&Zero::zero()) &&
 
-        self[3][0].approx_eq(&zero()) &&
-        self[3][1].approx_eq(&zero()) &&
-        self[3][2].approx_eq(&zero())
+        self[3][0].approx_eq(&Zero::zero()) &&
+        self[3][1].approx_eq(&Zero::zero()) &&
+        self[3][2].approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
@@ -1599,7 +1598,7 @@ impl<T:Copy + Float + NumAssign> BaseMat<T, Vec4<T>> for Mat4<T> {
 
     #[inline(always)]
     fn is_invertible(&self) -> bool {
-        !self.determinant().approx_eq(&zero())
+        !self.determinant().approx_eq(&Zero::zero())
     }
 
     #[inline(always)]
diff --git a/src/quat.rs b/src/quat.rs
index 9500460..1ded5c7 100644
--- a/src/quat.rs
+++ b/src/quat.rs
@@ -7,9 +7,9 @@
  *   Sir William Hamilton
  */
 
-use core::cmp::ApproxEq;
-use core::num::Zero::zero;
-use core::num::One::one;
+use std::cast::transmute;
+use std::cmp::ApproxEq;
+use std::num::{Zero, One};
 
 use mat::{Mat3, BaseMat3};
 use vec::{Vec3, BaseVec3, AffineVec, NumVec, NumVec3};
@@ -68,7 +68,10 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
      */
     #[inline(always)]
     fn identity() -> Quat<T> {
-        Quat::new(one(), zero(), zero(), zero())
+        Quat::new(One::one(),
+                  Zero::zero(),
+                  Zero::zero(),
+                  Zero::zero())
     }
 
     /**
@@ -78,25 +81,37 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
      */
     #[inline(always)]
     fn zero() -> Quat<T> {
-        Quat::new(zero(), zero(), zero(), zero())
+        Quat::new(Zero::zero(),
+                  Zero::zero(),
+                  Zero::zero(),
+                  Zero::zero())
     }
 
     #[inline(always)]
     fn from_angle_x(radians: T) -> Quat<T> {
         let _2 = num::cast(2);
-        Quat::new((radians / _2).cos(), radians.sin(), zero(), zero())
+        Quat::new((radians / _2).cos(),
+                  radians.sin(),
+                  Zero::zero(),
+                  Zero::zero())
     }
 
     #[inline(always)]
     fn from_angle_y(radians: T) -> Quat<T> {
         let _2 = num::cast(2);
-        Quat::new((radians / _2).cos(), zero(), radians.sin(), zero())
+        Quat::new((radians / _2).cos(),
+                  Zero::zero(),
+                  radians.sin(),
+                  Zero::zero())
     }
 
     #[inline(always)]
     fn from_angle_z(radians: T) -> Quat<T> {
         let _2 = num::cast(2);
-        Quat::new((radians / _2).cos(), zero(), zero(), radians.sin())
+        Quat::new((radians / _2).cos(),
+                  Zero::zero(),
+                  Zero::zero(),
+                  radians.sin())
     }
 
     #[inline(always)]
@@ -273,7 +288,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
      */
     #[inline(always)]
     fn normalize(&self) -> Quat<T> {
-        self.mul_t(one::<T>()/self.magnitude())
+        self.mul_t(One::one::<T>()/self.magnitude())
     }
 
     /**
@@ -285,7 +300,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
      */
     #[inline(always)]
     fn nlerp(&self, other: &Quat<T>, amount: T) -> Quat<T> {
-        self.mul_t(one::<T>() - amount).add_q(&other.mul_t(amount)).normalize()
+        self.mul_t(One::one::<T>() - amount).add_q(&other.mul_t(amount)).normalize()
     }
 
     /**
@@ -316,12 +331,13 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
         let dot_threshold = num::cast(0.9995);
 
         if dot > dot_threshold {
-            return self.nlerp(other, amount);                   // if quaternions are close together use `nlerp`
+            return self.nlerp(other, amount);               // if quaternions are close together use `nlerp`
         } else {
-            let robust_dot = dot.clamp(&-one::<T>(), &one());   // stay within the domain of acos()
+            let robust_dot = dot.clamp(&-One::one::<T>(),
+                                       &One::one());        // stay within the domain of acos()
 
-            let theta_0 = robust_dot.acos();                    // the angle between the quaternions
-            let theta = theta_0 * amount;                       // the fraction of theta specified by `amount`
+            let theta_0 = robust_dot.acos();                // the angle between the quaternions
+            let theta = theta_0 * amount;                   // the fraction of theta specified by `amount`
 
             let q = other.sub_q(&self.mul_t(robust_dot))
                          .normalize();
@@ -362,7 +378,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
         let sz2 = z2 * self.s;
         let sx2 = x2 * self.s;
 
-        let _1: T = one();
+        let _1: T = One::one();
 
         BaseMat3::new(_1 - yy2 - zz2,      xy2 + sz2,      xz2 - sy2,
                            xy2 - sz2, _1 - xx2 - zz2,      yz2 + sx2,
@@ -373,7 +389,7 @@ pub impl<T:Copy + Float + NumAssign> Quat<T> {
 impl<T:Copy> Index<uint, T> for Quat<T> {
     #[inline(always)]
     fn index(&self, i: &uint) -> T {
-        unsafe { do vec::raw::buf_as_slice(cast::transmute(self), 4) |slice| { slice[*i] } }
+        unsafe { transmute::<Quat<T>,[T,..4]>(*self)[*i] }
     }
 }
 
diff --git a/src/test/test_quat.rs b/src/test/test_quat.rs
index 97e8324..e8979db 100644
--- a/src/test/test_quat.rs
+++ b/src/test/test_quat.rs
@@ -1,5 +1,4 @@
 use std::cmp::FuzzyEq;
-use numeric::*;
 
 use mat::*;
 use quat::*;
@@ -32,13 +31,13 @@ fn test_quat() {
 fn test_quat_2() {
     let v = vec3::new(1f32, 0f32, 0f32);
     
-    let q = quat::from_angle_axis(radians(-45f32), &vec3::new(0f32, 0f32, -1f32));
+    let q = quat::from_angle_axis((-45f32).radians(), &vec3::new(0f32, 0f32, -1f32));
     
     // http://www.wolframalpha.com/input/?i={1,0}+rotate+-45+degrees
-    assert!(q.mul_v(&v).fuzzy_eq(&vec3::new(1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32)));
+    assert!(q.mul_v(&v).fuzzy_eq(&vec3::new(1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32)));
     assert!(q.mul_v(&v).length() == v.length());
-    assert!(q.to_mat3().fuzzy_eq(&mat3::new( 1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32,
-                                            -1f32/sqrt(2f32), 1f32/sqrt(2f32), 0f32,
+    assert!(q.to_mat3().fuzzy_eq(&mat3::new( 1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
+                                            -1f32/2f32.sqrt(), 1f32/2f32.sqrt(), 0f32,
                                                        0f32,           0f32, 1f32)));
 }
 
diff --git a/src/test/test_vec.rs b/src/test/test_vec.rs
index fa05268..567e9e7 100644
--- a/src/test/test_vec.rs
+++ b/src/test/test_vec.rs
@@ -1,6 +1,5 @@
 use std::cmp::FuzzyEq;
-use numeric::float::Float::frac_pi_2;
-use numeric::float::Float::frac_pi_3;
+use std::num::Real::{frac_pi_2, frac_pi_3};
 
 use vec::*;
 
@@ -9,79 +8,79 @@ use vec::*;
 #[test]
 fn test_vec2() {
     // assert!(vec2::dim == 2);
-    
+
     let a = Vec2 { x: 1.0, y: 2.0 };
     let b = Vec2 { x: 3.0, y: 4.0 };
     let f1 = 1.5;
     let f2 = 0.5;
-    
+
     let mut mut_a = a;
-    
+
     assert!(vec2::new(1.0, 2.0) == a);
     assert!(vec2::from_value(1.0) == vec2::new(1.0, 1.0));
-    
+
     assert!(vec2::zero()     == vec2::new(0.0, 0.0));
     assert!(vec2::unit_x()   == vec2::new(1.0, 0.0));
     assert!(vec2::unit_y()   == vec2::new(0.0, 1.0));
     assert!(vec2::identity() == vec2::new(1.0, 1.0));
-    
+
     *mut_a.index_mut(0) = 42.0;
     *mut_a.index_mut(1) = 43.0;
     assert!(mut_a == vec2::new(42.0, 43.0));
     mut_a = a;
-    
+
     mut_a.swap(0, 1);
     assert!(mut_a[0] == a[1]);
     assert!(mut_a[1] == a[0]);
     mut_a = a;
-    
+
     assert!(a.x == 1.0);
     assert!(a.y == 2.0);
     assert!(a[0] == 1.0);
     assert!(a[1] == 2.0);
-    
+
     assert!(-a      == vec2::new(-1.0, -2.0));
     assert!(a.neg() == vec2::new(-1.0, -2.0));
-    
+
     assert!(vec2::new(0.0, 0.0).is_zero());
     assert!(!vec2::new(1.0, 1.0).is_zero());
-    
+
     assert!(a.mul_t(f1) == vec2::new( 1.5, 3.0));
     assert!(a.div_t(f2) == vec2::new( 2.0, 4.0));
-    
+
     assert!(a.add_v(&b) == vec2::new(    4.0,     6.0));
     assert!(a.sub_v(&b) == vec2::new(   -2.0,    -2.0));
     assert!(a.mul_v(&b) == vec2::new(    3.0,     8.0));
     assert!(a.div_v(&b) == vec2::new(1.0/3.0, 2.0/4.0));
-    
+
     mut_a.neg_self();
     assert!(mut_a == -a);
     mut_a = a;
-    
+
     mut_a.mul_self_t(f1);
     assert!(mut_a == a.mul_t(f1));
     mut_a = a;
-    
+
     mut_a.div_self_t(f2);
     assert!(mut_a == a.div_t(f2));
     mut_a = a;
-    
+
     mut_a.add_self_v(&b);
     assert!(mut_a == a.add_v(&b));
     mut_a = a;
-    
+
     mut_a.sub_self_v(&b);
     assert!(mut_a == a.sub_v(&b));
     mut_a = a;
-    
+
     mut_a.mul_self_v(&b);
     assert!(mut_a == a.mul_v(&b));
     mut_a = a;
-    
+
     mut_a.div_self_v(&b);
     assert!(mut_a == a.div_v(&b));
     // mut_a = a;
-    
+
     // assert!(c.abs()       == vec2::new( 2.0,  1.0));
     // assert!(c.min(&d)      == vec2::new(-2.0, -1.0));
     // assert!(c.max(&d)      == vec2::new( 1.0,  0.0));
@@ -98,28 +97,28 @@ fn test_vec2_euclidean() {
     let a = vec2::new(5.0, 12.0); // (5, 12, 13) Pythagorean triple
     let b0 = vec2::new(3.0, 4.0); // (3, 4, 5) Pythagorean triple
     let b = a.add_v(&b0);
-    
+
     assert!(a.length() == 13.0);
     assert!(a.length2() == 13.0 * 13.0);
-    
+
     assert!(b0.length() == 5.0);
     assert!(b0.length2() == 5.0 * 5.0);
-    
+
     assert!(a.distance(&b) == 5.0);
     assert!(a.distance2(&b) == 5.0 * 5.0);
-    
+
     assert!(vec2::new(1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
     assert!(vec2::new(10.0, 0.0).angle(&vec2::new(0.0, 5.0)).fuzzy_eq(&frac_pi_2()));
     assert!(vec2::new(-1.0, 0.0).angle(&vec2::new(0.0, 1.0)).fuzzy_eq(&-frac_pi_2::<f32>()));
-    
+
     assert!(vec2::new(3.0, 4.0).normalize().fuzzy_eq(&vec2::new(3.0/5.0, 4.0/5.0)));
     // TODO: test normalize_to, normalize_self, and normalize_self_to
-    
+
     let c = vec2::new(-2.0, -1.0);
     let d = vec2::new( 1.0,  0.0);
-    
+
     assert!(c.lerp(&d, 0.75) == vec2::new(0.250, -0.250));
-    
+
     let mut mut_c = c;
     mut_c.lerp_self(&d, 0.75);
     assert!(mut_c == c.lerp(&d, 0.75));
@@ -130,15 +129,15 @@ fn test_vec2_boolean() {
     let tf = bvec2::new(true, false);
     let ff = bvec2::new(false, false);
     let tt = bvec2::new(true, true);
-    
+
     assert!(tf.any() == true);
     assert!(tf.all() == false);
     assert!(tf.not() == bvec2::new(false, true));
-    
+
     assert!(ff.any() == false);
     assert!(ff.all() == false);
     assert!(ff.not() == bvec2::new(true, true));
-    
+
     assert!(tt.any() == true);
     assert!(tt.all() == true);
     assert!(tt.not() == bvec2::new(false, false));
@@ -147,98 +146,98 @@ fn test_vec2_boolean() {
 #[test]
 fn test_vec3() {
     // assert!(Vec3::dim == 3);
-    
+
     let a = Vec3 { x: 1.0, y: 2.0, z: 3.0 };
     let b = Vec3 { x: 4.0, y: 5.0, z: 6.0 };
     let f1 = 1.5;
     let f2 = 0.5;
-    
+
     let mut mut_a = a;
-    
+
     assert!(vec3::new(1.0, 2.0, 3.0) == a);
     assert!(vec3::from_value(1.0) == vec3::new(1.0, 1.0, 1.0));
-    
+
     assert!(vec3::zero()     == vec3::new(0.0, 0.0, 0.0));
     assert!(vec3::unit_x()   == vec3::new(1.0, 0.0, 0.0));
     assert!(vec3::unit_y()   == vec3::new(0.0, 1.0, 0.0));
     assert!(vec3::unit_z()   == vec3::new(0.0, 0.0, 1.0));
     assert!(vec3::identity() == vec3::new(1.0, 1.0, 1.0));
-    
+
     *mut_a.index_mut(0) = 42.0;
     *mut_a.index_mut(1) = 43.0;
     *mut_a.index_mut(2) = 44.0;
     assert!(mut_a == vec3::new(42.0, 43.0, 44.0));
     mut_a = a;
-    
+
     mut_a.swap(0, 2);
     assert!(mut_a[0] == a[2]);
     assert!(mut_a[2] == a[0]);
     mut_a = a;
-    
+
     mut_a.swap(1, 2);
     assert!(mut_a[1] == a[2]);
     assert!(mut_a[2] == a[1]);
     mut_a = a;
-    
+
     assert!(a.x == 1.0);
     assert!(a.y == 2.0);
     assert!(a.z == 3.0);
     assert!(a[0] == 1.0);
     assert!(a[1] == 2.0);
     assert!(a[2] == 3.0);
-    
+
     assert!(a.cross(&b) == vec3::new(-3.0, 6.0, -3.0));
-    
+
     mut_a.cross_self(&b);
     assert!(mut_a == a.cross(&b));
     mut_a = a;
-    
+
     assert!(-a      == vec3::new(-1.0, -2.0, -3.0));
     assert!(a.neg() == vec3::new(-1.0, -2.0, -3.0));
-    
+
     assert!(vec3::new(0.0, 0.0, 0.0).is_zero());
     assert!(!vec3::new(1.0, 1.0, 1.0).is_zero());
-    
+
     assert!(a.mul_t(f1) == vec3::new( 1.5, 3.0, 4.5));
     assert!(a.div_t(f2) == vec3::new( 2.0, 4.0, 6.0));
-    
+
     assert!(a.add_v(&b) == vec3::new(    5.0,     7.0,     9.0));
     assert!(a.sub_v(&b) == vec3::new(   -3.0,    -3.0,    -3.0));
     assert!(a.mul_v(&b) == vec3::new(    4.0,    10.0,    18.0));
     assert!(a.div_v(&b) == vec3::new(1.0/4.0, 2.0/5.0, 3.0/6.0));
-    
+
     mut_a.neg_self();
     assert!(mut_a == -a);
     mut_a = a;
-    
+
     mut_a.mul_self_t(f1);
     assert!(mut_a == a.mul_t(f1));
     mut_a = a;
-    
+
     mut_a.div_self_t(f2);
     assert!(mut_a == a.div_t(f2));
     mut_a = a;
-    
+
     mut_a.add_self_v(&b);
     assert!(mut_a == a.add_v(&b));
     mut_a = a;
-    
+
     mut_a.sub_self_v(&b);
     assert!(mut_a == a.sub_v(&b));
     mut_a = a;
-    
+
     mut_a.mul_self_v(&b);
     assert!(mut_a == a.mul_v(&b));
     mut_a = a;
-    
+
     mut_a.div_self_v(&b);
     assert!(mut_a == a.div_v(&b));
     // mut_a = a;
-    
+
     // exact_eq
     // fuzzy_eq
     // eq
-    
+
     // assert!(c.abs()        == vec3::new( 2.0,  1.0, 1.0));
     // assert!(c.min(&d)      == vec3::new(-2.0, -1.0, 0.5));
     // assert!(c.max(&d)      == vec3::new( 1.0,  0.0, 1.0));
@@ -255,28 +254,28 @@ fn test_vec3_euclidean() {
     let a = vec3::new(2.0, 3.0, 6.0); // (2, 3, 6, 7) Pythagorean quadruple
     let b0 = vec3::new(1.0, 4.0, 8.0); // (1, 4, 8, 9) Pythagorean quadruple
     let b = a.add_v(&b0);
-    
+
     assert!(a.length() == 7.0);
     assert!(a.length2() == 7.0 * 7.0);
-    
+
     assert!(b0.length() == 9.0);
     assert!(b0.length2() == 9.0 * 9.0);
-    
+
     assert!(a.distance(&b) == 9.0);
     assert!(a.distance2(&b) == 9.0 * 9.0);
-    
+
     assert!(vec3::new(1.0, 0.0, 1.0).angle(&vec3::new(1.0, 1.0, 0.0)).fuzzy_eq(&frac_pi_3()));
     assert!(vec3::new(10.0, 0.0, 10.0).angle(&vec3::new(5.0, 5.0, 0.0)).fuzzy_eq(&frac_pi_3()));
     assert!(vec3::new(-1.0, 0.0, -1.0).angle(&vec3::new(1.0, -1.0, 0.0)).fuzzy_eq(&(2.0 * frac_pi_3())));
-    
+
     assert!(vec3::new(2.0, 3.0, 6.0).normalize().fuzzy_eq(&vec3::new(2.0/7.0, 3.0/7.0, 6.0/7.0)));
     // TODO: test normalize_to, normalize_self, and normalize_self_to
-    
+
     let c = vec3::new(-2.0, -1.0, 1.0);
     let d = vec3::new( 1.0,  0.0, 0.5);
-    
+
     assert!(c.lerp(&d, 0.75) == vec3::new(0.250, -0.250, 0.625));
-    
+
     let mut mut_c = c;
     mut_c.lerp_self(&d, 0.75);
     assert!(mut_c == c.lerp(&d, 0.75));
@@ -287,15 +286,15 @@ fn test_vec3_boolean() {
     let tft = bvec3::new(true, false, true);
     let fff = bvec3::new(false, false, false);
     let ttt = bvec3::new(true, true, true);
-    
+
     assert!(tft.any() == true);
     assert!(tft.all() == false);
     assert!(tft.not() == bvec3::new(false, true, false));
-    
+
     assert!(fff.any() == false);
     assert!(fff.all() == false);
     assert!(fff.not() == bvec3::new(true, true, true));
-    
+
     assert!(ttt.any() == true);
     assert!(ttt.all() == true);
     assert!(ttt.not() == bvec3::new(false, false, false));
@@ -304,41 +303,41 @@ fn test_vec3_boolean() {
 #[test]
 fn test_vec4() {
     // assert!(Vec4::dim == 4);
-    
+
     let a = Vec4 { x: 1.0, y: 2.0, z: 3.0, w: 4.0 };
     let b = Vec4 { x: 5.0, y: 6.0, z: 7.0, w: 8.0 };
     let f1 = 1.5;
     let f2 = 0.5;
-    
+
     let mut mut_a = a;
-    
+
     assert!(vec4::new(1.0, 2.0, 3.0, 4.0) == a);
     assert!(vec4::from_value(1.0) == vec4::new(1.0, 1.0, 1.0, 1.0));
-    
+
     *mut_a.index_mut(0) = 42.0;
     *mut_a.index_mut(1) = 43.0;
     *mut_a.index_mut(2) = 44.0;
     *mut_a.index_mut(3) = 45.0;
     assert!(mut_a == vec4::new(42.0, 43.0, 44.0, 45.0));
     mut_a = a;
-    
+
     mut_a.swap(0, 3);
     assert!(mut_a[0] == a[3]);
     assert!(mut_a[3] == a[0]);
     mut_a = a;
-    
+
     mut_a.swap(1, 2);
     assert!(mut_a[1] == a[2]);
     assert!(mut_a[2] == a[1]);
     mut_a = a;
-    
+
     assert!(vec4::zero()     == vec4::new(0.0, 0.0, 0.0, 0.0));
     assert!(vec4::unit_x()   == vec4::new(1.0, 0.0, 0.0, 0.0));
     assert!(vec4::unit_y()   == vec4::new(0.0, 1.0, 0.0, 0.0));
     assert!(vec4::unit_z()   == vec4::new(0.0, 0.0, 1.0, 0.0));
     assert!(vec4::unit_w()   == vec4::new(0.0, 0.0, 0.0, 1.0));
     assert!(vec4::identity() == vec4::new(1.0, 1.0, 1.0, 1.0));
-    
+
     assert!(a.x == 1.0);
     assert!(a.y == 2.0);
     assert!(a.z == 3.0);
@@ -347,51 +346,51 @@ fn test_vec4() {
     assert!(a[1] == 2.0);
     assert!(a[2] == 3.0);
     assert!(a[3] == 4.0);
-    
+
     assert!(-a      == vec4::new(-1.0, -2.0, -3.0, -4.0));
     assert!(a.neg() == vec4::new(-1.0, -2.0, -3.0, -4.0));
-    
+
     assert!(vec4::new(0.0, 0.0, 0.0, 0.0).is_zero());
     assert!(!vec4::new(1.0, 1.0, 1.0, 1.0).is_zero());
-    
+
     assert!(a.mul_t(f1) == vec4::new( 1.5, 3.0, 4.5, 6.0));
     assert!(a.div_t(f2) == vec4::new( 2.0, 4.0, 6.0, 8.0));
-    
+
     assert!(a.add_v(&b) == vec4::new(    6.0,     8.0,    10.0,    12.0));
     assert!(a.sub_v(&b) == vec4::new(   -4.0,    -4.0,    -4.0,    -4.0));
     assert!(a.mul_v(&b) == vec4::new(    5.0,    12.0,    21.0,    32.0));
     assert!(a.div_v(&b) == vec4::new(1.0/5.0, 2.0/6.0, 3.0/7.0, 4.0/8.0));
-    
+
     assert!(a.dot(&b) == 70.0);
-    
+
     mut_a.neg_self();
     assert!(mut_a == -a);
     mut_a = a;
-    
+
     mut_a.mul_self_t(f1);
     assert!(mut_a == a.mul_t(f1));
     mut_a = a;
-    
+
     mut_a.div_self_t(f2);
     assert!(mut_a == a.div_t(f2));
     mut_a = a;
-    
+
     mut_a.add_self_v(&b);
     assert!(mut_a == a.add_v(&b));
     mut_a = a;
-    
+
     mut_a.sub_self_v(&b);
     assert!(mut_a == a.sub_v(&b));
     mut_a = a;
-    
+
     mut_a.mul_self_v(&b);
     assert!(mut_a == a.mul_v(&b));
     mut_a = a;
-    
+
     mut_a.div_self_v(&b);
     assert!(mut_a == a.div_v(&b));
     // mut_a = a;
-    
+
     // assert!(c.abs()        == vec4::new( 2.0,  1.0, 1.0, 2.0));
     // assert!(c.min(&d)      == vec4::new(-2.0, -1.0, 0.5, 1.0));
     // assert!(c.max(&d)      == vec4::new( 1.0,  0.0, 1.0, 2.0));
@@ -408,28 +407,28 @@ fn test_vec4_euclidean() {
     let a = vec4::new(1.0, 2.0, 4.0, 10.0); // (1, 2, 4, 10, 11) Pythagorean quintuple
     let b0 = vec4::new(1.0, 2.0, 8.0, 10.0); // (1, 2, 8, 10, 13) Pythagorean quintuple
     let b = a.add_v(&b0);
-    
+
     assert!(a.length() == 11.0);
     assert!(a.length2() == 11.0 * 11.0);
-    
+
     assert!(b0.length() == 13.0);
     assert!(b0.length2() == 13.0 * 13.0);
-    
+
     assert!(a.distance(&b) == 13.0);
     assert!(a.distance2(&b) == 13.0 * 13.0);
-    
+
     assert!(vec4::new(1.0, 0.0, 1.0, 0.0).angle(&vec4::new(0.0, 1.0, 0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
     assert!(vec4::new(10.0, 0.0, 10.0, 0.0).angle(&vec4::new(0.0, 5.0, 0.0, 5.0)).fuzzy_eq(&frac_pi_2()));
     assert!(vec4::new(-1.0, 0.0, -1.0, 0.0).angle(&vec4::new(0.0, 1.0, 0.0, 1.0)).fuzzy_eq(&frac_pi_2()));
-    
+
     assert!(vec4::new(1.0, 2.0, 4.0, 10.0).normalize().fuzzy_eq(&vec4::new(1.0/11.0, 2.0/11.0, 4.0/11.0, 10.0/11.0)));
     // TODO: test normalize_to, normalize_self, and normalize_self_to
 
     let c = vec4::new(-2.0, -1.0, 1.0, 2.0);
     let d = vec4::new( 1.0,  0.0, 0.5, 1.0);
-    
+
     assert!(c.lerp(&d, 0.75) == vec4::new(0.250, -0.250, 0.625, 1.250));
-    
+
     let mut mut_c = c;
     mut_c.lerp_self(&d, 0.75);
     assert!(mut_c == c.lerp(&d, 0.75));
@@ -440,15 +439,15 @@ fn test_vec4_boolean() {
     let tftf = bvec4::new(true, false, true, false);
     let ffff = bvec4::new(false, false, false, false);
     let tttt = bvec4::new(true, true, true, true);
-    
+
     assert!(tftf.any() == true);
     assert!(tftf.all() == false);
     assert!(tftf.not() == bvec4::new(false, true, false, true));
-    
+
     assert!(ffff.any() == false);
     assert!(ffff.all() == false);
     assert!(ffff.not() == bvec4::new(true, true, true, true));
-    
+
     assert!(tttt.any() == true);
     assert!(tttt.all() == true);
     assert!(tttt.not() == bvec4::new(false, false, false, false));
diff --git a/src/vec.rs b/src/vec.rs
index 85cd3aa..e245ba4 100644
--- a/src/vec.rs
+++ b/src/vec.rs
@@ -1,8 +1,7 @@
-use core::cast::transmute;
-use core::cmp::ApproxEq;
-use core::num::Zero::zero;
-use core::num::One::one;
-use core::util;
+use std::cast::transmute;
+use std::cmp::ApproxEq;
+use std::num::{Zero, One};
+use std::util;
 
 use num::NumAssign;
 
@@ -538,7 +537,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec2<T> {
     #[inline(always)]
     fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
         unsafe {
-            &'a mut transmute::<
+            &mut transmute::<
                 &'a mut Vec2<T>,
                 &'a mut [T,..2]
             >(self)[i]
@@ -568,18 +567,20 @@ impl<T:Copy + Eq> Index<uint, T> for Vec2<T> {
 impl<T:Copy + Num + NumAssign> NumVec<T> for Vec2<T> {
     #[inline(always)]
     fn identity() -> Vec2<T> {
-        BaseVec2::new(one::<T>(), one::<T>())
+        BaseVec2::new(One::one::<T>(),
+                      One::one::<T>())
     }
 
     #[inline(always)]
     fn zero() -> Vec2<T> {
-        BaseVec2::new(zero::<T>(), zero::<T>())
+        BaseVec2::new(Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn is_zero(&self) -> bool {
-        self[0] == zero() &&
-        self[1] == zero()
+        self[0] == Zero::zero() &&
+        self[1] == Zero::zero()
     }
 
     #[inline(always)]
@@ -665,12 +666,14 @@ impl<T:Copy + Num> Neg<Vec2<T>> for Vec2<T> {
 impl<T:Copy + Num> NumVec2<T> for Vec2<T> {
     #[inline(always)]
     fn unit_x() -> Vec2<T> {
-        BaseVec2::new(one::<T>(), zero::<T>())
+        BaseVec2::new(One::one::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_y() -> Vec2<T> {
-        BaseVec2::new(zero::<T>(), one::<T>())
+        BaseVec2::new(Zero::zero::<T>(),
+                      One::one::<T>())
     }
 
     #[inline(always)]
@@ -682,7 +685,7 @@ impl<T:Copy + Num> NumVec2<T> for Vec2<T> {
 impl<T:Copy + Num> ToHomogeneous<Vec3<T>> for Vec2<T> {
     #[inline(always)]
     fn to_homogeneous(&self) -> Vec3<T> {
-        BaseVec3::new(self.x, self.y, zero())
+        BaseVec3::new(self.x, self.y, Zero::zero())
     }
 }
 
@@ -714,7 +717,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec2<T> {
 
     #[inline(always)]
     fn normalize(&self) -> Vec2<T> {
-        self.mul_t(one::<T>()/self.length())
+        self.mul_t(One::one::<T>()/self.length())
     }
 
     #[inline(always)]
@@ -729,7 +732,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec2<T> {
 
     #[inline(always)]
     fn normalize_self(&mut self) {
-        let n = one::<T>() / self.length();
+        let n = One::one::<T>() / self.length();
         self.mul_self_t(n);
     }
 
@@ -845,7 +848,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec3<T> {
     #[inline(always)]
     fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
         unsafe {
-            &'a mut transmute::<
+            &mut transmute::<
                 &'a mut Vec3<T>,
                 &'a mut [T,..3]
             >(self)[i]
@@ -875,19 +878,23 @@ impl<T:Copy + Eq> Index<uint, T> for Vec3<T> {
 impl<T:Copy + Num + NumAssign> NumVec<T> for Vec3<T> {
     #[inline(always)]
     fn identity() -> Vec3<T> {
-        BaseVec3::new(one::<T>(), one::<T>(), one::<T>())
+        BaseVec3::new(One::one::<T>(),
+                      One::one::<T>(),
+                      One::one::<T>())
     }
 
     #[inline(always)]
     fn zero() -> Vec3<T> {
-        BaseVec3::new(zero::<T>(), zero::<T>(), zero::<T>())
+        BaseVec3::new(Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn is_zero(&self) -> bool {
-        self[0] == zero() &&
-        self[1] == zero() &&
-        self[2] == zero()
+        self[0] == Zero::zero() &&
+        self[1] == Zero::zero() &&
+        self[2] == Zero::zero()
     }
 
     #[inline(always)]
@@ -975,17 +982,23 @@ impl<T:Copy + Num> Neg<Vec3<T>> for Vec3<T> {
 impl<T:Copy + Num> NumVec3<T> for Vec3<T> {
     #[inline(always)]
     fn unit_x() -> Vec3<T> {
-        BaseVec3::new(one::<T>(), zero::<T>(), zero::<T>())
+        BaseVec3::new(One::one::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_y() -> Vec3<T> {
-        BaseVec3::new(zero::<T>(), one::<T>(), zero::<T>())
+        BaseVec3::new(Zero::zero::<T>(),
+                      One::one::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_z() -> Vec3<T> {
-        BaseVec3::new(zero::<T>(), zero::<T>(), one::<T>())
+        BaseVec3::new(Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      One::one::<T>())
     }
 
     #[inline(always)]
@@ -1004,7 +1017,7 @@ impl<T:Copy + Num> NumVec3<T> for Vec3<T> {
 impl<T:Copy + Num> ToHomogeneous<Vec4<T>> for Vec3<T> {
     #[inline(always)]
     fn to_homogeneous(&self) -> Vec4<T> {
-        BaseVec4::new(self.x, self.y, self.z, zero())
+        BaseVec4::new(self.x, self.y, self.z, Zero::zero())
     }
 }
 
@@ -1036,7 +1049,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec3<T> {
 
     #[inline(always)]
     fn normalize(&self) -> Vec3<T> {
-        self.mul_t(one::<T>()/self.length())
+        self.mul_t(One::one::<T>()/self.length())
     }
 
     #[inline(always)]
@@ -1051,7 +1064,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec3<T> {
 
     #[inline(always)]
     fn normalize_self(&mut self) {
-        let n = one::<T>() / self.length();
+        let n = One::one::<T>() / self.length();
         self.mul_self_t(n);
     }
 
@@ -1169,7 +1182,7 @@ impl<T:Copy + Eq> BaseVec<T> for Vec4<T> {
     #[inline(always)]
     fn index_mut<'a>(&'a mut self, i: uint) -> &'a mut T {
         unsafe {
-            &'a mut transmute::<
+            &mut transmute::<
                 &'a mut Vec4<T>,
                 &'a mut [T,..4]
             >(self)[i]
@@ -1199,20 +1212,26 @@ impl<T:Copy + Eq> Index<uint, T> for Vec4<T> {
 impl<T:Copy + Num + NumAssign> NumVec<T> for Vec4<T> {
     #[inline(always)]
     fn identity() -> Vec4<T> {
-        BaseVec4::new(one::<T>(), one::<T>(), one::<T>(), one::<T>())
+        BaseVec4::new(One::one::<T>(),
+                      One::one::<T>(),
+                      One::one::<T>(),
+                      One::one::<T>())
     }
 
     #[inline(always)]
     fn zero() -> Vec4<T> {
-        BaseVec4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
+        BaseVec4::new(Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn is_zero(&self) -> bool {
-        self[0] == zero() &&
-        self[1] == zero() &&
-        self[2] == zero() &&
-        self[3] == zero()
+        self[0] == Zero::zero() &&
+        self[1] == Zero::zero() &&
+        self[2] == Zero::zero() &&
+        self[3] == Zero::zero()
     }
 
     #[inline(always)]
@@ -1302,22 +1321,34 @@ impl<T:Copy + Num> Neg<Vec4<T>> for Vec4<T> {
 impl<T:Copy + Num> NumVec4<T> for Vec4<T> {
     #[inline(always)]
     fn unit_x() -> Vec4<T> {
-        BaseVec4::new(one::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
+        BaseVec4::new(One::one::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_y() -> Vec4<T> {
-        BaseVec4::new(zero::<T>(), one::<T>(), zero::<T>(), zero::<T>())
+        BaseVec4::new(Zero::zero::<T>(),
+                      One::one::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_z() -> Vec4<T> {
-        BaseVec4::new(zero::<T>(), zero::<T>(), one::<T>(), zero::<T>())
+        BaseVec4::new(Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      One::one::<T>(),
+                      Zero::zero::<T>())
     }
 
     #[inline(always)]
     fn unit_w() -> Vec4<T> {
-        BaseVec4::new(zero::<T>(), zero::<T>(), zero::<T>(), one::<T>())
+        BaseVec4::new(Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      Zero::zero::<T>(),
+                      One::one::<T>())
     }
 }
 
@@ -1349,7 +1380,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec4<T> {
 
     #[inline(always)]
     fn normalize(&self) -> Vec4<T> {
-        self.mul_t(one::<T>()/self.length())
+        self.mul_t(One::one::<T>()/self.length())
     }
 
     #[inline(always)]
@@ -1364,7 +1395,7 @@ impl<T:Copy + Real + NumAssign> AffineVec<T> for Vec4<T> {
 
     #[inline(always)]
     fn normalize_self(&mut self) {
-        let n = one::<T>() / self.length();
+        let n = One::one::<T>() / self.length();
         self.mul_self_t(n);
     }