relative_eq()

geo-types/Cargo.toml

@@ -10,6 +10,9 @@ keywords = ["gis", "geo", "geography", "geospatial"]
 description = "Geospatial primitive data types"
 edition = "2018"
 
+[features]
+relative_eq = []
+
 [dependencies]
 approx = "0.4.0"
 num-traits = "0.2"

geo-types/src/coordinate.rs

@@ -1,7 +1,10 @@
 use crate::{CoordinateType, Point};
-#[cfg(test)]
-use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 
+#[cfg(any(feature = "relative_eq", test))]
+use approx::{AbsDiffEq, RelativeEq};
+
+#[cfg(test)]
+use approx::UlpsEq;
 /// A lightweight struct used to store coordinates on the 2-dimensional
 /// Cartesian plane.
 ///
@@ -240,31 +243,35 @@ impl<T: CoordinateType> Zero for Coordinate<T> {
     }
 }
 
-#[cfg(test)]
+#[cfg(feature = "relative_eq")]
 impl<T: CoordinateType + AbsDiffEq> AbsDiffEq for Coordinate<T>
 where
     T::Epsilon: Copy,
 {
     type Epsilon = T::Epsilon;
 
+    #[inline]
     fn default_epsilon() -> T::Epsilon {
         T::default_epsilon()
     }
 
+    #[inline]
     fn abs_diff_eq(&self, other: &Self, epsilon: T::Epsilon) -> bool {
         T::abs_diff_eq(&self.x, &other.x, epsilon) && T::abs_diff_eq(&self.y, &other.y, epsilon)
     }
 }
 
-#[cfg(test)]
+#[cfg(feature = "relative_eq")]
 impl<T: CoordinateType + RelativeEq> RelativeEq for Coordinate<T>
 where
     T::Epsilon: Copy,
 {
+    #[inline]
     fn default_max_relative() -> T::Epsilon {
         T::default_max_relative()
     }
 
+    #[inline]
     fn relative_eq(&self, other: &Self, epsilon: T::Epsilon, max_relative: T::Epsilon) -> bool {
         T::relative_eq(&self.x, &other.x, epsilon, max_relative)
             && T::relative_eq(&self.y, &other.y, epsilon, max_relative)

geo-types/src/line.rs

@@ -1,4 +1,8 @@
 use crate::{Coordinate, CoordinateType, Point};
+#[cfg(feature = "relative_eq")]
+use approx::AbsDiffEq;
+#[cfg(feature = "relative_eq")]
+use approx::RelativeEq;
 
 /// A line segment made up of exactly two
 /// [`Coordinate`s](struct.Coordinate.html).
@@ -164,6 +168,66 @@ impl<T: CoordinateType> From<[(T, T); 2]> for Line<T> {
         Line::new(coord[0], coord[1])
     }
 }
+#[cfg(feature = "relative_eq")]
+impl<T> RelativeEq for Line<T>
+where
+    T: AbsDiffEq<Epsilon = T> + CoordinateType + RelativeEq,
+{
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    /// Equality assertion within a relative limit.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use geo_types::{Coordinate, Line};
+    ///
+    /// let a = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1., y: 1. });
+    /// let b = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1.001, y: 1. });
+    ///
+    /// approx::assert_relative_eq!(a, b, max_relative=0.1)
+    /// ```
+    #[inline]
+    fn relative_eq(
+        &self,
+        other: &Self,
+        epsilon: Self::Epsilon,
+        max_relative: Self::Epsilon,
+    ) -> bool {
+        self.start.relative_eq(&other.start, epsilon, max_relative)
+            && self.end.relative_eq(&other.end, epsilon, max_relative)
+    }
+}
+
+#[cfg(feature = "relative_eq")]
+impl<T: AbsDiffEq<Epsilon = T> + CoordinateType> AbsDiffEq for Line<T> {
+    type Epsilon = T;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    /// Equality assertion within a relative limit.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use geo_types::{Coordinate, Line};
+    ///
+    /// let a = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1., y: 1. });
+    /// let b = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1.001, y: 1. });
+    ///
+    /// approx::assert_relative_eq!(a, b, epsilon=0.1)
+    /// ```
+    #[inline]
+    fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
+        self.start.abs_diff_eq(&other.start, epsilon) && self.end.abs_diff_eq(&other.end, epsilon)
+    }
+}
 
 #[cfg(feature = "rstar")]
 impl<T> ::rstar::RTreeObject for Line<T>
@@ -188,3 +252,82 @@ where
         d.powi(2)
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_abs_diff_eq() {
+        let delta = 1e-6;
+        let line = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1., y: 1. });
+        let line_start_x = Line::new(
+            Point(Coordinate {
+                x: 0. + delta,
+                y: 0.,
+            }),
+            Point(Coordinate { x: 1., y: 1. }),
+        );
+        assert!(line.abs_diff_eq(&line_start_x, 1e-2));
+        assert!(line.abs_diff_ne(&line_start_x, 1e-12));
+
+        let line_start_y = Line::new(
+            Coordinate {
+                x: 0.,
+                y: 0. + delta,
+            },
+            Coordinate { x: 1., y: 1. },
+        );
+        assert!(line.abs_diff_eq(&line_start_y, 1e-2));
+        assert!(line.abs_diff_ne(&line_start_y, 1e-12));
+
+        let line_end_x = Line::new(
+            Coordinate { x: 0., y: 0. },
+            Coordinate {
+                x: 1. + delta,
+                y: 1.,
+            },
+        );
+
+        assert!(line.abs_diff_eq(&line_end_x, 1e-2));
+        assert!(line.abs_diff_ne(&line_end_x, 1e-12));
+
+        let line_end_y = Line::new(
+            Coordinate { x: 0., y: 0. },
+            Coordinate {
+                x: 1.,
+                y: 1. + delta,
+            },
+        );
+
+        assert!(line.abs_diff_eq(&line_end_y, 1e-2));
+        assert!(line.abs_diff_ne(&line_end_y, 1e-12));
+    }
+
+    #[test]
+    fn test_relative_eq() {
+        let delta = 1e-6;
+
+        let line = Line::new(Coordinate { x: 0., y: 0. }, Coordinate { x: 1., y: 1. });
+        let line_start_x = Line::new(
+            Point(Coordinate {
+                x: 0. + delta,
+                y: 0.,
+            }),
+            Point(Coordinate { x: 1., y: 1. }),
+        );
+        let line_start_y = Line::new(
+            Coordinate {
+                x: 0.,
+                y: 0. + delta,
+            },
+            Coordinate { x: 1., y: 1. },
+        );
+
+        assert!(line.relative_eq(&line_start_x, 1e-2, 1e-2));
+        assert!(line.relative_ne(&line_start_x, 1e-12, 1e-12));
+
+        assert!(line.relative_eq(&line_start_y, 1e-2, 1e-2));
+        assert!(line.relative_ne(&line_start_y, 1e-12, 1e-12));
+    }
+}

geo-types/src/line_string.rs

@@ -1,3 +1,8 @@
+#[cfg(feature = "relative_eq")]
+use approx::AbsDiffEq;
+#[cfg(feature = "relative_eq")]
+use approx::RelativeEq;
+
 use crate::{Coordinate, CoordinateType, Line, Point, Triangle};
 use std::iter::FromIterator;
 use std::ops::{Index, IndexMut};
@@ -282,6 +287,86 @@ impl<T: CoordinateType> IndexMut<usize> for LineString<T> {
     }
 }
 
+#[cfg(feature = "relative_eq")]
+impl<T> RelativeEq for LineString<T>
+where
+    T: AbsDiffEq<Epsilon = T> + CoordinateType + RelativeEq,
+{
+    #[inline]
+    fn default_max_relative() -> Self::Epsilon {
+        T::default_max_relative()
+    }
+
+    /// Equality assertion within a relative limit.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use geo_types::LineString;
+    ///
+    /// let mut coords_a = vec![(0., 0.), (5., 0.), (7., 9.)];
+    /// let a: LineString<f32> = coords_a.into_iter().collect();
+    ///
+    /// let mut coords_b = vec![(0., 0.), (5., 0.), (7.001, 9.)];
+    /// let b: LineString<f32> = coords_b.into_iter().collect();
+    ///
+    /// approx::assert_relative_eq!(a, b, max_relative=0.1)
+    /// ```
+    ///
+    fn relative_eq(
+        &self,
+        other: &Self,
+        epsilon: Self::Epsilon,
+        max_relative: Self::Epsilon,
+    ) -> bool {
+        if self.0.len() != other.0.len() {
+            return false;
+        }
+
+        let points_zipper = self.points_iter().zip(other.points_iter());
+        for (lhs, rhs) in points_zipper {
+            if lhs.relative_ne(&rhs, epsilon, max_relative) {
+                return false;
+            }
+        }
+
+        true
+    }
+}
+
+#[cfg(feature = "relative_eq")]
+impl<T: AbsDiffEq<Epsilon = T> + CoordinateType> AbsDiffEq for LineString<T> {
+    type Epsilon = T;
+
+    #[inline]
+    fn default_epsilon() -> Self::Epsilon {
+        T::default_epsilon()
+    }
+
+    /// Equality assertion within a relative limit.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use geo_types::LineString;
+    ///
+    /// let mut coords_a = vec![(0., 0.), (5., 0.), (7., 9.)];
+    /// let a: LineString<f32> = coords_a.into_iter().collect();
+    ///
+    /// let mut coords_b = vec![(0., 0.), (5., 0.), (7.001, 9.)];
+    /// let b: LineString<f32> = coords_b.into_iter().collect();
+    ///
+    /// approx::assert_relative_eq!(a, b, epsilon=0.1)
+    /// ```
+    fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool {
+        if self.0.len() != other.0.len() {
+            return false;
+        }
+        let mut points_zipper = self.points_iter().zip(other.points_iter());
+        points_zipper.all(|(lhs, rhs)| lhs.abs_diff_eq(&rhs, epsilon))
+    }
+}
+
 #[cfg(feature = "rstar")]
 impl<T> ::rstar::RTreeObject for LineString<T>
 where
@@ -319,3 +404,66 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use approx::AbsDiffEq;
+
+    #[test]
+    fn test_abs_diff_eq() {
+        let delta = 1e-6;
+
+        let coords = vec![(0., 0.), (5., 0.), (10., 10.)];
+        let ls: LineString<f32> = coords.into_iter().collect();
+
+        let coords_x = vec![(0., 0.), (5. + delta, 0.), (10., 10.)];
+        let ls_x: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.abs_diff_eq(&ls_x, 1e-2));
+        assert!(ls.abs_diff_ne(&ls_x, 1e-12));
+
+        let coords_y = vec![(0., 0.), (5., 0. + delta), (10., 10.)];
+        let ls_y: LineString<f32> = coords_y.into_iter().collect();
+        assert!(ls.abs_diff_eq(&ls_y, 1e-2));
+        assert!(ls.abs_diff_ne(&ls_y, 1e-12));
+
+        // Undersized, but otherwise equal.
+        let coords_x = vec![(0., 0.), (5., 0.)];
+        let ls_under: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.abs_diff_ne(&ls_under, 1.));
+
+        // Oversized, but otherwise equal.
+        let coords_x = vec![(0., 0.), (5., 0.), (10., 10.), (10., 100.)];
+        let ls_oversized: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.abs_diff_ne(&ls_oversized, 1.));
+    }
+
+    #[test]
+    fn test_relative_eq() {
+        let delta = 1e-6;
+
+        let coords = vec![(0., 0.), (5., 0.), (10., 10.)];
+        let ls: LineString<f32> = coords.into_iter().collect();
+
+        let coords_x = vec![(0., 0.), (5. + delta, 0.), (10., 10.)];
+        let ls_x: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.relative_eq(&ls_x, 1e-2, 1e-2));
+        assert!(ls.relative_ne(&ls_x, 1e-12, 1e-12));
+
+        let coords_y = vec![(0., 0.), (5., 0. + delta), (10., 10.)];
+        let ls_y: LineString<f32> = coords_y.into_iter().collect();
+        assert!(ls.relative_eq(&ls_y, 1e-2, 1e-2));
+        assert!(ls.relative_ne(&ls_y, 1e-12, 1e-12));
+
+        // Undersized, but otherwise equal.
+        let coords_x = vec![(0., 0.), (5., 0.)];
+        let ls_under: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.relative_ne(&ls_under, 1., 1.));
+
+        // Oversized, but otherwise equal.
+        let coords_x = vec![(0., 0.), (5., 0.), (10., 10.), (10., 100.)];
+        let ls_oversized: LineString<f32> = coords_x.into_iter().collect();
+        assert!(ls.relative_ne(&ls_oversized, 1., 1.));
+    }
+}