Formatting

Author: Andlon

fenris-geometry/src/lib.rs

@@ -11,10 +11,10 @@ use std::fmt::Debug;
 mod polygon;
 mod polytope;
 mod primitives;
+use crate::util::index_set_nth_power_iter;
 pub use polygon::*;
 pub use polytope::*;
 pub use primitives::*;
-use crate::util::{index_set_nth_power_iter};
 
 pub mod polymesh;
 pub mod sdf;
@@ -153,10 +153,18 @@ where
 {
     /// Computes the minimal bounding box which encloses both `this` and `other`.
     pub fn enclose(&self, other: &AxisAlignedBoundingBox<T, D>) -> Self {
-        let min = self.min.iter().zip(&other.min.coords).map(|(a, b)| T::min(*a, *b));
+        let min = self
+            .min
+            .iter()
+            .zip(&other.min.coords)
+            .map(|(a, b)| T::min(*a, *b));
         let min = OVector::<T, D>::from_iterator(min);
 
-        let max = self.max.iter().zip(&other.max.coords).map(|(a, b)| T::max(*a, *b));
+        let max = self
+            .max
+            .iter()
+            .zip(&other.max.coords)
+            .map(|(a, b)| T::max(*a, *b));
         let max = OVector::<T, D>::from_iterator(max);
 
         AxisAlignedBoundingBox::new(min.into(), max.into())
@@ -242,20 +250,20 @@ where
     }
 
     /// Creates an iterator over the corners of the bounding box.
-    pub fn corners_iter<'a>(&'a self) -> impl 'a + Iterator<Item=OPoint<T, D>>
+    pub fn corners_iter<'a>(&'a self) -> impl 'a + Iterator<Item = OPoint<T, D>>
     where
-        DefaultAllocator: Allocator<usize, D>
+        DefaultAllocator: Allocator<usize, D>,
     {
         // We can enumerate the corners by looking at {0, 1}^D, i.e. the D-th power of the
         // set {0, 1}, and associating 0 and 1 with min and max coordinates for the i-th axis.
-        index_set_nth_power_iter::<D>(2)
-            .map(move |multi_idx| {
-                OVector::<T, D>::from_fn(|idx, _| match multi_idx[idx] {
-                    0 => self.min[idx].clone(),
-                    1 => self.max[idx].clone(),
-                    _ => unreachable!()
-                }).into()
+        index_set_nth_power_iter::<D>(2).map(move |multi_idx| {
+            OVector::<T, D>::from_fn(|idx, _| match multi_idx[idx] {
+                0 => self.min[idx].clone(),
+                1 => self.max[idx].clone(),
+                _ => unreachable!(),
             })
+            .into()
+        })
     }
 
     /// Compute the point in the bounding box furthest away from the given point.
@@ -271,22 +279,21 @@ where
     #[replace_float_literals(T::from_f64(literal).unwrap())]
     pub fn furthest_point_to(&self, point: &OPoint<T, D>) -> OPoint<T, D>
     where
-        DefaultAllocator: Allocator<usize, D>
+        DefaultAllocator: Allocator<usize, D>,
     {
         // It turns out that we can choose, along each dimension, the point in the interval
         // [a_i, b_i] furthest away from p_i.
-        point.coords.zip_zip_map(
-            &self.min.coords,
-            &self.max.coords,
-            |p_i, a_i, b_i| {
+        point
+            .coords
+            .zip_zip_map(&self.min.coords, &self.max.coords, |p_i, a_i, b_i| {
                 let mid = (a_i + b_i) / 2.0;
                 if p_i < mid {
                     b_i
                 } else {
                     a_i
                 }
-            }
-        ).into()
+            })
+            .into()
     }
 
     /// The squared distance to the point in the bounding box furthest away from the given point.
@@ -297,7 +304,7 @@ where
     pub fn max_dist2_to(&self, point: &OPoint<T, D>) -> T
     where
         // TODO: Use DimAllocator and SmallDim
-        DefaultAllocator: Allocator<usize, D>
+        DefaultAllocator: Allocator<usize, D>,
     {
         (self.furthest_point_to(point) - point).norm_squared()
     }
@@ -309,8 +316,8 @@ where
     /// Panic behavior is identical to [`max_dist2_to`](Self::max_dist2_to).
     pub fn max_dist_to(&self, point: &OPoint<T, D>) -> T
     where
-    // TODO: Use DimAllocator and SmallDim
-        DefaultAllocator: Allocator<usize, D>
+        // TODO: Use DimAllocator and SmallDim
+        DefaultAllocator: Allocator<usize, D>,
     {
         self.max_dist2_to(point).sqrt()
     }

fenris-geometry/src/proptest.rs

@@ -1,29 +1,35 @@
 use crate::Orientation::Counterclockwise;
-use crate::{AxisAlignedBoundingBox, AxisAlignedBoundingBox2d, AxisAlignedBoundingBox3d, HalfPlane, LineSegment2d, Orientation, Quad2d, Triangle, Triangle2d, Triangle3d};
-use nalgebra::proptest::vector;
-use nalgebra::{DimName, Point2, Point3, Unit, Vector2, Vector3, U2, U3, DefaultAllocator, RealField};
+use crate::{
+    AxisAlignedBoundingBox, AxisAlignedBoundingBox2d, AxisAlignedBoundingBox3d, HalfPlane, LineSegment2d, Orientation,
+    Quad2d, Triangle, Triangle2d, Triangle3d,
+};
 use nalgebra::allocator::Allocator;
+use nalgebra::proptest::vector;
+use nalgebra::{DefaultAllocator, DimName, Point2, Point3, RealField, Unit, Vector2, Vector3, U2, U3};
 use proptest::prelude::*;
 
-pub fn aabb<D>() -> impl Strategy<Value=AxisAlignedBoundingBox<f64, D>>
+pub fn aabb<D>() -> impl Strategy<Value = AxisAlignedBoundingBox<f64, D>>
 where
     D: DimName,
-    DefaultAllocator: Allocator<f64, D>
+    DefaultAllocator: Allocator<f64, D>,
 {
-    let value_strategy = -10.0 .. 10.0;
-    (vector(value_strategy.clone(), D::name()), vector(value_strategy, D::name()))
+    let value_strategy = -10.0..10.0;
+    (
+        vector(value_strategy.clone(), D::name()),
+        vector(value_strategy, D::name()),
+    )
         .prop_map(|(a, b)| {
             let min = a.zip_map(&b, |a_i, b_i| RealField::min(a_i, b_i));
             let max = a.zip_map(&b, |a_i, b_i| RealField::max(a_i, b_i));
             AxisAlignedBoundingBox::new(min.into(), max.into())
         })
 }
 
-pub fn aabb2() -> impl Strategy<Value=AxisAlignedBoundingBox2d<f64>> {
+pub fn aabb2() -> impl Strategy<Value = AxisAlignedBoundingBox2d<f64>> {
     aabb()
 }
 
-pub fn aabb3() -> impl Strategy<Value=AxisAlignedBoundingBox3d<f64>> {
+pub fn aabb3() -> impl Strategy<Value = AxisAlignedBoundingBox3d<f64>> {
     aabb()
 }
 

fenris-geometry/src/sdf.rs

@@ -1,5 +1,5 @@
 use fenris_traits::Real;
-use nalgebra::{Point2, Scalar, Vector2, U2, OPoint};
+use nalgebra::{OPoint, Point2, Scalar, Vector2, U2};
 
 use crate::{AxisAlignedBoundingBox2d, BoundedGeometry};
 use numeric_literals::replace_float_literals;

fenris-geometry/src/util.rs

@@ -1,6 +1,6 @@
 use fenris_traits::Real;
-use nalgebra::{DefaultAllocator, DimName, OVector, UnitVector3, Vector3};
 use nalgebra::allocator::Allocator;
+use nalgebra::{DefaultAllocator, DimName, OVector, UnitVector3, Vector3};
 
 pub fn compute_orthonormal_vectors_3d<T: Real>(vector: &UnitVector3<T>) -> [UnitVector3<T>; 2] {
     // Ported from
@@ -90,7 +90,7 @@ macro_rules! assert_line_segments_approx_equal {
 /// TODO: Currently only implicitly tested through [`AxisAlignedBoundingBox::corners_iter`].
 pub(crate) fn index_set_nth_power_iter<D: DimName>(n: usize) -> impl Iterator<Item = OVector<usize, D>>
 where
-    DefaultAllocator: Allocator<usize, D>
+    DefaultAllocator: Allocator<usize, D>,
 {
     let mut multi_idx = OVector::from_element(0);
     let mut i = 0;
@@ -111,4 +111,4 @@ where
             None
         }
     })
-}
+}

fenris-geometry/tests/unit_tests/aabb.rs

@@ -1,11 +1,11 @@
-use matrixcompare::assert_scalar_eq;
-use fenris_geometry::AxisAlignedBoundingBox;
-use nalgebra::{DefaultAllocator, DimName, OPoint, point, U2};
-use nalgebra::allocator::Allocator;
-use proptest::prelude::*;
 use fenris::allocators::DimAllocator;
 use fenris_geometry::proptest::{aabb2, aabb3, point2, point3};
+use fenris_geometry::AxisAlignedBoundingBox;
+use matrixcompare::assert_scalar_eq;
+use nalgebra::allocator::Allocator;
 use nalgebra::distance_squared;
+use nalgebra::{point, DefaultAllocator, DimName, OPoint, U2};
+use proptest::prelude::*;
 
 #[test]
 fn aabb_intersects_2d() {
@@ -48,54 +48,44 @@ fn aabb_intersects_2d() {
 }
 
 /// Helper function for collecting corners from corner iterator.
-fn corners<D: DimName>(aabb:& AxisAlignedBoundingBox<f64, D>) -> Vec<OPoint<f64, D>>
+fn corners<D: DimName>(aabb: &AxisAlignedBoundingBox<f64, D>) -> Vec<OPoint<f64, D>>
 where
-    DefaultAllocator: DimAllocator<f64, D>
+    DefaultAllocator: DimAllocator<f64, D>,
 {
     aabb.corners_iter().collect()
 }
 
 fn compare_unordered_points<D: DimName>(points1: &[OPoint<f64, D>], points2: &[OPoint<f64, D>]) -> bool
 where
-    DefaultAllocator: Allocator<f64, D>
+    DefaultAllocator: Allocator<f64, D>,
 {
     assert_eq!(points1.len(), points2.len());
     // This is O(n^2) but is acceptable for use in tests here
-    points1.iter()
-        .all(|p1| points2.contains(p1))
+    points1.iter().all(|p1| points2.contains(p1))
 }
 
 macro_rules! assert_unordered_eq {
-    ($p1:expr, $p2:expr) => {
-        {
-            let eq = compare_unordered_points((&$p1).as_ref(), (&$p2).as_ref());
-            if !eq {
-                dbg!(&$p1, &$p2);
-                assert!(eq, "Point lists do not contain the same points");
-            }
+    ($p1:expr, $p2:expr) => {{
+        let eq = compare_unordered_points((&$p1).as_ref(), (&$p2).as_ref());
+        if !eq {
+            dbg!(&$p1, &$p2);
+            assert!(eq, "Point lists do not contain the same points");
         }
-    }
+    }};
 }
 
-
 #[test]
 fn test_aabb_corners_iter() {
-
     // 1D
     {
         let aabb = AxisAlignedBoundingBox::new(point![3.0], point![4.0]);
-        assert_eq!(corners(&aabb), vec![ point![3.0 ], point![4.0] ]);
+        assert_eq!(corners(&aabb), vec![point![3.0], point![4.0]]);
     }
 
     // 2D
     {
         let aabb = AxisAlignedBoundingBox::new(point![3.0, 4.0], point![5.0, 6.0]);
-        let expected = [
-            [3.0, 4.0],
-            [3.0, 6.0],
-            [5.0, 4.0],
-            [5.0, 6.0]
-        ].map(OPoint::from);
+        let expected = [[3.0, 4.0], [3.0, 6.0], [5.0, 4.0], [5.0, 6.0]].map(OPoint::from);
         assert_unordered_eq!(corners(&aabb), &expected);
     }
 
@@ -110,8 +100,9 @@ fn test_aabb_corners_iter() {
             [4.0, 2.0, 3.0],
             [4.0, 2.0, 6.0],
             [4.0, 5.0, 3.0],
-            [4.0, 5.0, 6.0]
-        ].map(OPoint::from);
+            [4.0, 5.0, 6.0],
+        ]
+        .map(OPoint::from);
         assert_unordered_eq!(corners(&aabb), expected);
     }
 }
@@ -195,4 +186,4 @@ proptest! {
         prop_assert!(aabb.contains_point(&q));
     }
 
-}
+}

src/allocators.rs

@@ -21,4 +21,4 @@ where
 {
 }
 
-pub use fenris_traits::allocators::*;
+pub use fenris_traits::allocators::*;