From a3965d414df9e2e89cb1dd1d6219e0f16d145bab Mon Sep 17 00:00:00 2001
From: Alex Butler <alexheretic@gmail.com>
Date: Wed, 23 May 2018 12:43:52 +0100
Subject: [PATCH] Update approx -> 0.2

---
 Cargo.toml        |  2 +-
 src/angle.rs      | 23 ++++++++++-----
 src/euler.rs      | 25 ++++++++++++-----
 src/matrix.rs     | 71 ++++++++++++++++++++++++++++++++++-------------
 src/num.rs        | 24 ++++++++++++----
 src/point.rs      | 25 ++++++++++++-----
 src/quaternion.rs | 24 +++++++++++-----
 src/rotation.rs   | 50 +++++++++++++++++++++++----------
 src/structure.rs  | 14 +++++++---
 src/transform.rs  | 43 ++++++++++++++++++++--------
 src/vector.rs     | 44 ++++++++++++++++++++---------
 11 files changed, 248 insertions(+), 97 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 933eac4..905eb68 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,7 @@ unstable = []
 swizzle = []
 
 [dependencies]
-approx = "0.1"
+approx = "0.2"
 mint = { version = "0.5", optional = true }
 num-traits = "0.2"
 rand = "0.4"
diff --git a/src/angle.rs b/src/angle.rs
index 1ab5938..188b90e 100644
--- a/src/angle.rs
+++ b/src/angle.rs
@@ -26,7 +26,7 @@ use num_traits::{cast, Bounded};
 
 use structure::*;
 
-use approx::ApproxEq;
+use approx;
 use num::BaseFloat;
 
 /// An angle, in radians.
@@ -170,7 +170,7 @@ macro_rules! impl_angle {
             fn div_assign(&mut self, scalar) { self.0 /= scalar; }
         });
 
-        impl<S: BaseFloat> ApproxEq for $Angle<S> {
+        impl<S: BaseFloat> approx::AbsDiffEq for $Angle<S> {
             type Epsilon = S::Epsilon;
 
             #[inline]
@@ -178,20 +178,29 @@ macro_rules! impl_angle {
                 S::default_epsilon()
             }
 
+            #[inline]
+            fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+                S::abs_diff_eq(&self.0, &other.0, epsilon)
+            }
+        }
+
+        impl<S: BaseFloat> approx::RelativeEq for $Angle<S> {
             #[inline]
             fn default_max_relative() -> S::Epsilon {
                 S::default_max_relative()
             }
 
-            #[inline]
-            fn default_max_ulps() -> u32 {
-                S::default_max_ulps()
-            }
-
             #[inline]
             fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
                 S::relative_eq(&self.0, &other.0, epsilon, max_relative)
             }
+        }
+
+        impl<S: BaseFloat> approx::UlpsEq for $Angle<S> {
+            #[inline]
+            fn default_max_ulps() -> u32 {
+                S::default_max_ulps()
+            }
 
             #[inline]
             fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/euler.rs b/src/euler.rs
index b3661fd..c5bfa31 100644
--- a/src/euler.rs
+++ b/src/euler.rs
@@ -19,7 +19,7 @@ use num_traits::cast;
 use structure::*;
 
 use angle::Rad;
-use approx::ApproxEq;
+use approx;
 use quaternion::Quaternion;
 #[cfg(feature = "mint")]
 use mint;
@@ -141,7 +141,7 @@ impl<S: BaseFloat> From<Quaternion<S>> for Euler<Rad<S>> {
     }
 }
 
-impl<A: Angle> ApproxEq for Euler<A> {
+impl<A: Angle> approx::AbsDiffEq for Euler<A> {
     type Epsilon = A::Epsilon;
 
     #[inline]
@@ -149,22 +149,33 @@ impl<A: Angle> ApproxEq for Euler<A> {
         A::default_epsilon()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: A::Epsilon) -> bool {
+        A::abs_diff_eq(&self.x, &other.x, epsilon)
+            && A::abs_diff_eq(&self.y, &other.y, epsilon)
+            && A::abs_diff_eq(&self.z, &other.z, epsilon)
+    }
+}
+
+impl<A: Angle> approx::RelativeEq for Euler<A> {
     #[inline]
     fn default_max_relative() -> A::Epsilon {
         A::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        A::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: A::Epsilon, max_relative: A::Epsilon) -> bool {
         A::relative_eq(&self.x, &other.x, epsilon, max_relative)
             && A::relative_eq(&self.y, &other.y, epsilon, max_relative)
             && A::relative_eq(&self.z, &other.z, epsilon, max_relative)
     }
+}
+
+impl<A: Angle> approx::UlpsEq for Euler<A> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        A::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: A::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/matrix.rs b/src/matrix.rs
index c5606d1..f000b4f 100644
--- a/src/matrix.rs
+++ b/src/matrix.rs
@@ -24,7 +24,7 @@ use std::ptr;
 use structure::*;
 
 use angle::Rad;
-use approx::ApproxEq;
+use approx;
 use euler::Euler;
 use num::BaseFloat;
 use point::{Point2, Point3};
@@ -831,7 +831,7 @@ impl<S: BaseFloat> SquareMatrix for Matrix4<S> {
     }
 }
 
-impl<S: BaseFloat> ApproxEq for Matrix2<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Matrix2<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -839,21 +839,31 @@ impl<S: BaseFloat> ApproxEq for Matrix2<S> {
         cast(1.0e-6f64).unwrap()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        Vector2::abs_diff_eq(&self[0], &other[0], epsilon)
+            && Vector2::abs_diff_eq(&self[1], &other[1], epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Matrix2<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         Vector2::relative_eq(&self[0], &other[0], epsilon, max_relative)
             && Vector2::relative_eq(&self[1], &other[1], epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Matrix2<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
@@ -862,7 +872,7 @@ impl<S: BaseFloat> ApproxEq for Matrix2<S> {
     }
 }
 
-impl<S: BaseFloat> ApproxEq for Matrix3<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Matrix3<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -870,22 +880,33 @@ impl<S: BaseFloat> ApproxEq for Matrix3<S> {
         cast(1.0e-6f64).unwrap()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        Vector3::abs_diff_eq(&self[0], &other[0], epsilon)
+            && Vector3::abs_diff_eq(&self[1], &other[1], epsilon)
+            && Vector3::abs_diff_eq(&self[2], &other[2], epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Matrix3<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         Vector3::relative_eq(&self[0], &other[0], epsilon, max_relative)
             && Vector3::relative_eq(&self[1], &other[1], epsilon, max_relative)
             && Vector3::relative_eq(&self[2], &other[2], epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Matrix3<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
@@ -895,7 +916,7 @@ impl<S: BaseFloat> ApproxEq for Matrix3<S> {
     }
 }
 
-impl<S: BaseFloat> ApproxEq for Matrix4<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Matrix4<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -903,16 +924,21 @@ impl<S: BaseFloat> ApproxEq for Matrix4<S> {
         cast(1.0e-6f64).unwrap()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        Vector4::abs_diff_eq(&self[0], &other[0], epsilon)
+            && Vector4::abs_diff_eq(&self[1], &other[1], epsilon)
+            && Vector4::abs_diff_eq(&self[2], &other[2], epsilon)
+            && Vector4::abs_diff_eq(&self[3], &other[3], epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Matrix4<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         Vector4::relative_eq(&self[0], &other[0], epsilon, max_relative)
@@ -920,6 +946,13 @@ impl<S: BaseFloat> ApproxEq for Matrix4<S> {
             && Vector4::relative_eq(&self[2], &other[2], epsilon, max_relative)
             && Vector4::relative_eq(&self[3], &other[3], epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Matrix4<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/num.rs b/src/num.rs
index bcf57f5..113a4f2 100644
--- a/src/num.rs
+++ b/src/num.rs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use approx::ApproxEq;
+use approx;
 
 use std::fmt;
 use std::ops::*;
@@ -21,8 +21,8 @@ use std::ops::*;
 use num_traits::{Float, Num, NumCast};
 
 /// Base numeric types with partial ordering
-pub trait BaseNum
-    : Copy
+pub trait BaseNum:
+    Copy
     + Clone
     + fmt::Debug
     + Num
@@ -32,7 +32,8 @@ pub trait BaseNum
     + SubAssign
     + MulAssign
     + DivAssign
-    + RemAssign {
+    + RemAssign
+{
 }
 
 impl<T> BaseNum for T
@@ -52,10 +53,21 @@ where
 }
 
 /// Base floating point types
-pub trait BaseFloat: BaseNum + Float + ApproxEq<Epsilon = Self> {}
+pub trait BaseFloat:
+    BaseNum
+    + Float
+    + approx::AbsDiffEq<Epsilon = Self>
+    + approx::RelativeEq<Epsilon = Self>
+    + approx::UlpsEq<Epsilon = Self>
+{
+}
 
 impl<T> BaseFloat for T
 where
-    T: BaseNum + Float + ApproxEq<Epsilon = Self>,
+    T: BaseNum
+        + Float
+        + approx::AbsDiffEq<Epsilon = Self>
+        + approx::RelativeEq<Epsilon = Self>
+        + approx::UlpsEq<Epsilon = Self>,
 {
 }
diff --git a/src/point.rs b/src/point.rs
index 980d496..aef5e0c 100644
--- a/src/point.rs
+++ b/src/point.rs
@@ -24,7 +24,7 @@ use std::ops::*;
 
 use structure::*;
 
-use approx::ApproxEq;
+use approx;
 use num::{BaseFloat, BaseNum};
 use vector::{Vector1, Vector2, Vector3, Vector4};
 
@@ -172,7 +172,7 @@ macro_rules! impl_point {
             }
         }
 
-        impl<S: BaseFloat> ApproxEq for $PointN<S> {
+        impl<S: BaseFloat> approx::AbsDiffEq for $PointN<S> {
             type Epsilon = S::Epsilon;
 
             #[inline]
@@ -180,20 +180,31 @@ macro_rules! impl_point {
                 S::default_epsilon()
             }
 
+            #[inline]
+            fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon)
+            -> bool
+            {
+                $(S::abs_diff_eq(&self.$field, &other.$field, epsilon))&&+
+            }
+        }
+
+        impl<S: BaseFloat> approx::RelativeEq for $PointN<S> {
             #[inline]
             fn default_max_relative() -> S::Epsilon {
                 S::default_max_relative()
             }
 
-            #[inline]
-            fn default_max_ulps() -> u32 {
-                S::default_max_ulps()
-            }
-
             #[inline]
             fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
                 $(S::relative_eq(&self.$field, &other.$field, epsilon, max_relative))&&+
             }
+        }
+
+        impl<S: BaseFloat> approx::UlpsEq for $PointN<S> {
+            #[inline]
+            fn default_max_ulps() -> u32 {
+                S::default_max_ulps()
+            }
 
             #[inline]
             fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/quaternion.rs b/src/quaternion.rs
index 8723785..b2f01a4 100644
--- a/src/quaternion.rs
+++ b/src/quaternion.rs
@@ -23,7 +23,7 @@ use num_traits::{cast, NumCast};
 use structure::*;
 
 use angle::Rad;
-use approx::ApproxEq;
+use approx;
 use euler::Euler;
 use matrix::{Matrix3, Matrix4};
 use num::BaseFloat;
@@ -587,7 +587,7 @@ impl_scalar_mul!(f64);
 impl_scalar_div!(f32);
 impl_scalar_div!(f64);
 
-impl<S: BaseFloat> ApproxEq for Quaternion<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Quaternion<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -595,21 +595,31 @@ impl<S: BaseFloat> ApproxEq for Quaternion<S> {
         S::default_epsilon()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        S::abs_diff_eq(&self.s, &other.s, epsilon)
+            && Vector3::abs_diff_eq(&self.v, &other.v, epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Quaternion<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         S::relative_eq(&self.s, &other.s, epsilon, max_relative)
             && Vector3::relative_eq(&self.v, &other.v, epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Quaternion<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/rotation.rs b/src/rotation.rs
index 70344ec..86a6ea5 100644
--- a/src/rotation.rs
+++ b/src/rotation.rs
@@ -20,7 +20,7 @@ use std::ops::*;
 use structure::*;
 
 use angle::Rad;
-use approx::ApproxEq;
+use approx;
 use euler::Euler;
 use matrix::{Matrix2, Matrix3};
 use num::BaseFloat;
@@ -33,7 +33,9 @@ use vector::{Vector2, Vector3};
 pub trait Rotation<P: EuclideanSpace>: Sized + Copy + One
 where
     // FIXME: Ugly type signatures - blocked by rust-lang/rust#24092
-    Self: ApproxEq<Epsilon = P::Scalar>,
+    Self: approx::AbsDiffEq<Epsilon = P::Scalar>,
+    Self: approx::RelativeEq<Epsilon = P::Scalar>,
+    Self: approx::UlpsEq<Epsilon = P::Scalar>,
     P::Scalar: BaseFloat,
     Self: iter::Product<Self>,
 {
@@ -113,7 +115,7 @@ pub trait Rotation3<S: BaseFloat>
 /// use cgmath::Vector2;
 /// use cgmath::{Matrix, Matrix2};
 /// use cgmath::{Rotation, Rotation2, Basis2};
-/// use cgmath::ApproxEq;
+/// use cgmath::UlpsEq;
 /// use std::f64;
 ///
 /// // For simplicity, we will rotate the unit x vector to the unit y vector --
@@ -213,7 +215,7 @@ impl_operator!(<S: BaseFloat> Mul<Basis2<S> > for Basis2<S> {
     fn mul(lhs, rhs) -> Basis2<S> { Basis2 { mat: lhs.mat * rhs.mat  } }
 });
 
-impl<S: BaseFloat> ApproxEq for Basis2<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Basis2<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -221,20 +223,29 @@ impl<S: BaseFloat> ApproxEq for Basis2<S> {
         S::default_epsilon()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        Matrix2::abs_diff_eq(&self.mat, &other.mat, epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Basis2<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         Matrix2::relative_eq(&self.mat, &other.mat, epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Basis2<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
@@ -356,7 +367,7 @@ impl_operator!(<S: BaseFloat> Mul<Basis3<S> > for Basis3<S> {
     fn mul(lhs, rhs) -> Basis3<S> { Basis3 { mat: lhs.mat * rhs.mat  } }
 });
 
-impl<S: BaseFloat> ApproxEq for Basis3<S> {
+impl<S: BaseFloat> approx::AbsDiffEq for Basis3<S> {
     type Epsilon = S::Epsilon;
 
     #[inline]
@@ -364,20 +375,29 @@ impl<S: BaseFloat> ApproxEq for Basis3<S> {
         S::default_epsilon()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+        Matrix3::abs_diff_eq(&self.mat, &other.mat, epsilon)
+    }
+}
+
+impl<S: BaseFloat> approx::RelativeEq for Basis3<S> {
     #[inline]
     fn default_max_relative() -> S::Epsilon {
         S::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        S::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
         Matrix3::relative_eq(&self.mat, &other.mat, epsilon, max_relative)
     }
+}
+
+impl<S: BaseFloat> approx::UlpsEq for Basis3<S> {
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        S::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
diff --git a/src/structure.rs b/src/structure.rs
index 75eadeb..299d6f0 100644
--- a/src/structure.rs
+++ b/src/structure.rs
@@ -20,7 +20,7 @@ use std::cmp;
 use std::iter;
 use std::ops::*;
 
-use approx::ApproxEq;
+use approx;
 
 use angle::Rad;
 use num::{BaseFloat, BaseNum};
@@ -215,7 +215,9 @@ where
     // FIXME: Ugly type signatures - blocked by rust-lang/rust#24092
     <Self as VectorSpace>::Scalar: BaseFloat,
     Self: MetricSpace<Metric = <Self as VectorSpace>::Scalar>,
-    Self: ApproxEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    // Self: approx::AbsDiffEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    // Self: approx::RelativeEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    Self: approx::UlpsEq<Epsilon = <Self as VectorSpace>::Scalar>,
 {
     /// Vector dot (or inner) product.
     fn dot(self, other: Self) -> Self::Scalar;
@@ -430,7 +432,9 @@ where
     // FIXME: Ugly type signatures - blocked by rust-lang/rust#24092
     Self: Index<usize, Output = <Self as Matrix>::Column>,
     Self: IndexMut<usize, Output = <Self as Matrix>::Column>,
-    Self: ApproxEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    Self: approx::AbsDiffEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    Self: approx::RelativeEq<Epsilon = <Self as VectorSpace>::Scalar>,
+    Self: approx::UlpsEq<Epsilon = <Self as VectorSpace>::Scalar>,
 {
     /// The row vector of the matrix.
     type Row: VectorSpace<Scalar = Self::Scalar> + Array<Element = Self::Scalar>;
@@ -570,7 +574,9 @@ where
     Self: Copy + Clone,
     Self: PartialEq + cmp::PartialOrd,
     // FIXME: Ugly type signatures - blocked by rust-lang/rust#24092
-    Self: ApproxEq<Epsilon = <Self as Angle>::Unitless>,
+    Self: approx::AbsDiffEq<Epsilon = <Self as Angle>::Unitless>,
+    Self: approx::RelativeEq<Epsilon = <Self as Angle>::Unitless>,
+    Self: approx::UlpsEq<Epsilon = <Self as Angle>::Unitless>,
 
     Self: Zero,
 
diff --git a/src/transform.rs b/src/transform.rs
index 1d09358..f3d3113 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -15,7 +15,7 @@
 
 use structure::*;
 
-use approx::ApproxEq;
+use approx;
 use matrix::{Matrix2, Matrix3, Matrix4};
 use num::{BaseFloat, BaseNum};
 use point::{Point2, Point3};
@@ -62,7 +62,7 @@ pub trait Transform<P: EuclideanSpace>: Sized {
 
 /// A generic transformation consisting of a rotation,
 /// displacement vector and scale amount.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub struct Decomposed<V: VectorSpace, R> {
     pub scale: V::Scalar,
     pub rot: R,
@@ -163,11 +163,11 @@ impl<S: BaseFloat, R: Rotation2<S>> Transform2<S> for Decomposed<Vector2<S>, R>
 
 impl<S: BaseFloat, R: Rotation3<S>> Transform3<S> for Decomposed<Vector3<S>, R> {}
 
-impl<S: VectorSpace, R, E: BaseFloat> ApproxEq for Decomposed<S, R>
+impl<S: VectorSpace, R, E: BaseFloat> approx::AbsDiffEq for Decomposed<S, R>
 where
-    S: ApproxEq<Epsilon = E>,
-    S::Scalar: ApproxEq<Epsilon = E>,
-    R: ApproxEq<Epsilon = E>,
+    S: approx::AbsDiffEq<Epsilon = E>,
+    S::Scalar: approx::AbsDiffEq<Epsilon = E>,
+    R: approx::AbsDiffEq<Epsilon = E>,
 {
     type Epsilon = E;
 
@@ -176,22 +176,43 @@ where
         E::default_epsilon()
     }
 
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: E) -> bool {
+        S::Scalar::abs_diff_eq(&self.scale, &other.scale, epsilon)
+            && R::abs_diff_eq(&self.rot, &other.rot, epsilon)
+            && S::abs_diff_eq(&self.disp, &other.disp, epsilon)
+    }
+}
+
+impl<S: VectorSpace, R, E: BaseFloat> approx::RelativeEq for Decomposed<S, R>
+where
+    S: approx::RelativeEq<Epsilon = E>,
+    S::Scalar: approx::RelativeEq<Epsilon = E>,
+    R: approx::RelativeEq<Epsilon = E>,
+{
     #[inline]
     fn default_max_relative() -> E {
         E::default_max_relative()
     }
 
-    #[inline]
-    fn default_max_ulps() -> u32 {
-        E::default_max_ulps()
-    }
-
     #[inline]
     fn relative_eq(&self, other: &Self, epsilon: E, max_relative: E) -> bool {
         S::Scalar::relative_eq(&self.scale, &other.scale, epsilon, max_relative)
             && R::relative_eq(&self.rot, &other.rot, epsilon, max_relative)
             && S::relative_eq(&self.disp, &other.disp, epsilon, max_relative)
     }
+}
+
+impl<S: VectorSpace, R, E: BaseFloat> approx::UlpsEq for Decomposed<S, R>
+where
+    S: approx::UlpsEq<Epsilon = E>,
+    S::Scalar: approx::UlpsEq<Epsilon = E>,
+    R: approx::UlpsEq<Epsilon = E>,
+{
+    #[inline]
+    fn default_max_ulps() -> u32 {
+        E::default_max_ulps()
+    }
 
     #[inline]
     fn ulps_eq(&self, other: &Self, epsilon: E, max_ulps: u32) -> bool {
diff --git a/src/vector.rs b/src/vector.rs
index 055c7e0..0e9da00 100644
--- a/src/vector.rs
+++ b/src/vector.rs
@@ -23,7 +23,7 @@ use std::ops::*;
 use structure::*;
 
 use angle::Rad;
-use approx::ApproxEq;
+use approx;
 use num::{BaseFloat, BaseNum};
 
 #[cfg(feature = "simd")]
@@ -206,7 +206,7 @@ macro_rules! impl_vector {
             fn neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) }
         }
 
-        impl<S: BaseFloat> ApproxEq for $VectorN<S> {
+        impl<S: BaseFloat> approx::AbsDiffEq for $VectorN<S> {
             type Epsilon = S::Epsilon;
 
             #[inline]
@@ -214,20 +214,29 @@ macro_rules! impl_vector {
                 S::default_epsilon()
             }
 
+            #[inline]
+            fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+                $(S::abs_diff_eq(&self.$field, &other.$field, epsilon))&&+
+            }
+        }
+
+        impl<S: BaseFloat> approx::RelativeEq for $VectorN<S> {
             #[inline]
             fn default_max_relative() -> S::Epsilon {
                 S::default_max_relative()
             }
 
-            #[inline]
-            fn default_max_ulps() -> u32 {
-                S::default_max_ulps()
-            }
-
             #[inline]
             fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
                 $(S::relative_eq(&self.$field, &other.$field, epsilon, max_relative))&&+
             }
+        }
+
+        impl<S: BaseFloat> approx::UlpsEq for $VectorN<S> {
+            #[inline]
+            fn default_max_ulps() -> u32 {
+                S::default_max_ulps()
+            }
 
             #[inline]
             fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {
@@ -452,7 +461,7 @@ macro_rules! impl_vector_default {
             default fn neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) }
         }
 
-        impl<S: BaseFloat> ApproxEq for $VectorN<S> {
+        impl<S: BaseFloat> approx::AbsDiffEq for $VectorN<S> {
             type Epsilon = S::Epsilon;
 
             #[inline]
@@ -460,20 +469,29 @@ macro_rules! impl_vector_default {
                 S::default_epsilon()
             }
 
+            #[inline]
+            fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool {
+                $(S::abs_diff_eq(&self.$field, &other.$field, epsilon))&&+
+            }
+        }
+
+        impl<S: BaseFloat> approx::RelativeEq for $VectorN<S> {
             #[inline]
             fn default_max_relative() -> S::Epsilon {
                 S::default_max_relative()
             }
 
-            #[inline]
-            fn default_max_ulps() -> u32 {
-                S::default_max_ulps()
-            }
-
             #[inline]
             fn relative_eq(&self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon) -> bool {
                 $(S::relative_eq(&self.$field, &other.$field, epsilon, max_relative))&&+
             }
+        }
+
+        impl<S: BaseFloat> approx::UlpsEq for $VectorN<S> {
+            #[inline]
+            fn default_max_ulps() -> u32 {
+                S::default_max_ulps()
+            }
 
             #[inline]
             fn ulps_eq(&self, other: &Self, epsilon: S::Epsilon, max_ulps: u32) -> bool {