engeom 0.2.15__tar.gz → 0.2.16__tar.gz

{engeom-0.2.15 → engeom-0.2.16}/Cargo.lock

@@ -147,12 +147,6 @@ dependencies = [
  "syn 2.0.104",
 ]
 
-[[package]]
-name = "array-init"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d62b7694a562cdf5a74227903507c56ab2cc8bdd1f781ed5cb4cf9c9f810bfc"
-
 [[package]]
 name = "arrayref"
 version = "0.3.9"
@@ -207,12 +201,6 @@ dependencies = [
  "arrayvec",
 ]
 
-[[package]]
-name = "az"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973"
-
 [[package]]
 name = "bit_field"
 version = "0.10.2"
@@ -449,12 +437,6 @@ version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
 
-[[package]]
-name = "cmov"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1dc960ba75d543267db9254da8ec1cb318a037beb3f8d2497520e410096fab"
-
 [[package]]
 name = "color_quant"
 version = "1.1.0"
@@ -664,12 +646,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd0c93bb4b0c6d9b77f4435b0ae98c24d17f1c45b2ff844c6151a07256ca923b"
 
-[[package]]
-name = "divrem"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69dde51e8fef5e12c1d65e0929b03d66e4c0c18282bc30ed2ca050ad6f44dd82"
-
 [[package]]
 name = "dlib"
 version = "0.5.2"
@@ -679,12 +655,6 @@ dependencies = [
  "libloading 0.8.8",
 ]
 
-[[package]]
-name = "doc-comment"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
-
 [[package]]
 name = "downcast-rs"
 version = "1.2.1"
@@ -723,7 +693,7 @@ dependencies = [
 
 [[package]]
 name = "engeom"
-version = "0.2.15"
+version = "0.2.16"
 dependencies = [
  "alum",
  "approx 0.5.1",
@@ -733,7 +703,7 @@ dependencies = [
  "faer",
  "imageproc",
  "itertools 0.14.0",
- "kiddo",
+ "kdtree",
  "levenberg-marquardt",
  "num-traits",
  "parry2d-f64",
@@ -885,19 +855,6 @@ dependencies = [
  "simd-adler32",
 ]
 
-[[package]]
-name = "fixed"
-version = "1.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "707070ccf8c4173548210893a0186e29c266901b71ed20cd9e2ca0193dfe95c3"
-dependencies = [
- "az",
- "bytemuck",
- "half",
- "num-traits",
- "typenum",
-]
-
 [[package]]
 name = "flate2"
 version = "1.1.2"
@@ -1441,32 +1398,21 @@ dependencies = [
 ]
 
 [[package]]
-name = "khronos_api"
-version = "3.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
-
-[[package]]
-name = "kiddo"
-version = "5.2.1"
+name = "kdtree"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52d0b22e8069fa029e15b7b0bf5bccc6d10c6abd26c3447970f708e2ee543afb"
+checksum = "0f0a0e9f770b65bac9aad00f97a67ab5c5319effed07f6da385da3c2115e47ba"
 dependencies = [
- "aligned-vec",
- "array-init",
- "az",
- "cmov",
- "divrem",
- "doc-comment",
- "fixed",
- "generator",
  "num-traits",
- "ordered-float",
- "sorted-vec",
- "tracing",
- "tracing-subscriber",
+ "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "khronos_api"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
+
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -2417,7 +2363,7 @@ dependencies = [
 
 [[package]]
 name = "py-engeom"
-version = "0.2.15"
+version = "0.2.16"
 dependencies = [
  "engeom",
  "numpy",
@@ -3065,12 +3011,6 @@ dependencies = [
  "wayland-protocols",
 ]
 
-[[package]]
-name = "sorted-vec"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d372029cb5195f9ab4e4b9aef550787dce78b124fcaee8d82519925defcd6f0d"
-
 [[package]]
 name = "spade"
 version = "2.14.0"
@@ -3408,21 +3348,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
  "pin-project-lite",
- "tracing-attributes",
  "tracing-core",
 ]
 
-[[package]]
-name = "tracing-attributes"
-version = "0.1.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "tracing-core"
 version = "0.1.34"

{engeom-0.2.15 → engeom-0.2.16}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["engeom", "py-engeom"]
 
 [workspace.package]
-version = "0.2.15"
+version = "0.2.16"
 edition = "2024"
 
 [workspace.dependencies]

{engeom-0.2.15 → engeom-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engeom
-Version: 0.2.15
+Version: 0.2.16
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{engeom-0.2.15 → engeom-0.2.16}/engeom/Cargo.toml

@@ -22,10 +22,10 @@ bitvec = {version = "1.0.1", features = ["serde"]}
 serde_json = "1.0.140"
 itertools = "0.14.0"
 levenberg-marquardt = "0.14.0"
-kiddo = "5.2.1"
 stl_io = { version = "0.8.5", optional = true }
 num-traits = "0.2.19"
 faer = "0.22.6"
+kdtree = "0.7.0"
 
 imageproc = "0.25.0"
 colorgrad = "0.7.2"

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/airfoil/helpers.rs

@@ -244,16 +244,16 @@ pub fn extract_edge_sub_curve(
 
     let perimeter = section.length();
 
-    if let Some(p0) = portion0 {
-        if p0.length() < perimeter * frac {
-            return Some(p0);
-        }
+    if let Some(p0) = portion0
+        && p0.length() < perimeter * frac
+    {
+        return Some(p0);
     }
 
-    if let Some(p1) = portion1 {
-        if p1.length() < perimeter * frac {
-            return Some(p1);
-        }
+    if let Some(p1) = portion1
+        && p1.length() < perimeter * frac
+    {
+        return Some(p1);
     }
 
     None
@@ -357,10 +357,10 @@ impl OrientedCircles {
     pub fn push(&mut self, circle: InscribedCircle) {
         let mut c = circle;
 
-        if let Some(last) = self.last() {
-            if last.spanning_ray.dir().dot(&c.spanning_ray.dir()) < 0.0 {
-                c.reverse_in_place();
-            }
+        if let Some(last) = self.last()
+            && last.spanning_ray.dir().dot(&c.spanning_ray.dir()) < 0.0
+        {
+            c.reverse_in_place();
         }
 
         if self.reversed {

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/discrete_domain.rs

@@ -177,6 +177,35 @@ impl DiscreteDomain {
     pub fn bounds_unchecked(&self) -> Interval {
         Interval::new(self.values[0], self.values[self.values.len() - 1])
     }
+
+    pub fn closest_index(&self, value: f64) -> Option<usize> {
+        if self.is_empty() {
+            return None;
+        }
+        if self.len() == 1 {
+            return Some(0);
+        }
+        if value >= self.values[self.len() - 1] {
+            return Some(self.len() - 1);
+        }
+        if value <= self.values[0] {
+            return Some(0);
+        }
+
+        let index = self.index_of(value)?;
+        if index == self.len() - 1 {
+            return Some(self.len() - 1);
+        }
+
+        let lower_value = self.values[index];
+        let upper_value = self.values[index + 1];
+
+        if (value - lower_value).abs() < (value - upper_value).abs() {
+            Some(index)
+        } else {
+            Some(index + 1)
+        }
+    }
 }
 
 impl Deref for DiscreteDomain {
@@ -210,6 +239,7 @@ impl TryFrom<Vec<f64>> for DiscreteDomain {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rand::Rng;
     use test_case::test_case;
 
     #[test]
@@ -272,4 +302,38 @@ mod tests {
         let domain = DiscreteDomain::try_from(vec![1.0, 2.0, 3.0]).unwrap();
         assert_eq!(domain.index_of(x), expected);
     }
+
+    fn brute_force_closest_index(domain: &DiscreteDomain, value: f64) -> Option<usize> {
+        if domain.is_empty() {
+            return None;
+        }
+        let mut closest_index = 0;
+        let mut closest_distance = (value - domain.values[0]).abs();
+        for (i, &v) in domain.values.iter().enumerate() {
+            let distance = (value - v).abs();
+            if distance < closest_distance {
+                closest_distance = distance;
+                closest_index = i;
+            }
+        }
+        Some(closest_index)
+    }
+
+    #[test]
+    fn stress_test_closest() {
+        let n = 1000;
+        let mut rng = rand::rng();
+        let domain = DiscreteDomain::linear(-10.0, 10.0, 100);
+        for _ in 0..n {
+            let test_val = rng.random_range(-12.0..12.0);
+            let closest_index = domain.closest_index(test_val);
+            let expected = brute_force_closest_index(&domain, test_val);
+
+            assert_eq!(
+                closest_index, expected,
+                "Failed for test value: {}",
+                test_val
+            );
+        }
+    }
 }

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/domain_window.rs

@@ -16,7 +16,7 @@
 /// ```
 ///
 /// ```
-pub fn iter_domain_window(domain: &[f64], window_size: f64) -> DomainWindowIter {
+pub fn iter_domain_window(domain: &[f64], window_size: f64) -> DomainWindowIter<'_> {
     DomainWindowIter::new(domain, window_size)
 }
 

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/index_mask.rs

@@ -64,7 +64,7 @@ impl IndexMask {
         self.mask.len()
     }
 
-    pub fn iter_true(&self) -> MaskTrueIterator {
+    pub fn iter_true(&self) -> MaskTrueIterator<'_> {
         MaskTrueIterator {
             mask: self,
             current: 0,
@@ -279,6 +279,12 @@ impl IndexMask {
         }
         Ok(())
     }
+
+    pub fn fill(&mut self, value: bool) {
+        for u in self.mask.as_raw_mut_slice() {
+            *u = if value { !0 } else { 0 };
+        }
+    }
 }
 
 pub struct MaskTrueIterator<'a> {

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/kd_tree.rs

@@ -1,9 +1,24 @@
+use crate::Result;
 use crate::common::{IndexMask, PCoords};
-use kiddo::SquaredEuclidean;
-use kiddo::immutable::float::kdtree;
-use std::num::NonZero;
+use kdtree::KdTree as KdTreeInner;
+use kdtree::distance::squared_euclidean;
 use uuid::Uuid;
 
+// fn check_tree() {
+//     let a: ([f64; 2], usize) = ([0f64, 0f64], 0);
+//     let b: ([f64; 2], usize) = ([1f64, 1f64], 1);
+//     let c: ([f64; 2], usize) = ([2f64, 2f64], 2);
+//     let d: ([f64; 2], usize) = ([3f64, 3f64], 3);
+//
+//     let dimensions = 2;
+//     let mut kdtree = KdTreeInner::new(dimensions);
+//
+//     kdtree.add(&a.0, a.1).unwrap();
+//     kdtree.add(&b.0, b.1).unwrap();
+//     kdtree.add(&c.0, c.1).unwrap();
+//     kdtree.add(&d.0, d.1).unwrap();
+// }
+
 /// A KD tree associated with a unique UUID, such that it can be checked to be matched against a
 /// specific entity.  The idea is that the UUID of the associated object will change if the object
 /// points are modified, and thus the matched tree can be validated before use.
@@ -28,7 +43,7 @@ impl<const D: usize> MatchedTree<D> {
 
 pub trait KdTreeSearch<const D: usize> {
     fn nearest_one(&self, point: &impl PCoords<D>) -> (usize, f64);
-    fn nearest(&self, point: &impl PCoords<D>, count: NonZero<usize>) -> Vec<(usize, f64)>;
+    fn nearest(&self, point: &impl PCoords<D>, count: usize) -> Vec<(usize, f64)>;
     fn within(&self, point: &impl PCoords<D>, radius: f64) -> Vec<(usize, f64)>;
 
     fn len(&self) -> usize;
@@ -39,7 +54,7 @@ pub trait KdTreeSearch<const D: usize> {
 
 /// An immutable k-dimensional tree for fast searches on points in D dimensions
 pub struct KdTree<const D: usize> {
-    tree: kdtree::ImmutableKdTree<f64, usize, D, 32>,
+    tree: KdTreeInner<f64, usize, [f64; D]>,
 }
 
 impl<const D: usize> KdTree<D> {
@@ -50,20 +65,16 @@ impl<const D: usize> KdTree<D> {
     /// * `points`: A slice of points.
     ///
     /// returns: KdTree<{ D }>
-    pub fn new(points: &[impl PCoords<D>]) -> Self {
+    pub fn new(points: &[impl PCoords<D>]) -> Result<Self> {
         let mut entries: Vec<[f64; D]> = Vec::with_capacity(points.len());
         for p in points {
             entries.push(p.coords().into());
         }
-        Self {
-            tree: kdtree::ImmutableKdTree::new_from_slice(&entries),
-        }
-    }
-
-    pub fn from_slice(s: &[[f64; D]]) -> Self {
-        Self {
-            tree: kdtree::ImmutableKdTree::new_from_slice(s),
+        let mut tree = KdTreeInner::new(D);
+        for (i, e) in entries.iter().enumerate() {
+            tree.add(*e, i)?;
         }
+        Ok(Self { tree })
     }
 }
 
@@ -84,10 +95,15 @@ impl<const D: usize> KdTreeSearch<D> for KdTree<D> {
     ///
     /// ```
     fn nearest_one(&self, point: &impl PCoords<D>) -> (usize, f64) {
-        let result = self
+        if let Ok(item) = self
             .tree
-            .nearest_one::<SquaredEuclidean>(&point.coords().into());
-        (result.item, result.distance.sqrt())
+            .nearest(point.coords().as_slice(), 1, &squared_euclidean)
+        {
+            let (d, u) = &item[0];
+            (**u, d.sqrt())
+        } else {
+            (usize::MAX, f64::INFINITY)
+        }
     }
 
     /// Find the nearest `count` points in the kd-tree to a given point.
@@ -104,14 +120,16 @@ impl<const D: usize> KdTreeSearch<D> for KdTree<D> {
     /// ```
     ///
     /// ```
-    fn nearest(&self, point: &impl PCoords<D>, count: NonZero<usize>) -> Vec<(usize, f64)> {
+    fn nearest(&self, point: &impl PCoords<D>, count: usize) -> Vec<(usize, f64)> {
         let result = self
             .tree
-            .nearest_n::<SquaredEuclidean>(&point.coords().into(), count);
-        result
-            .iter()
-            .map(|r| (r.item, r.distance.sqrt()))
-            .collect::<Vec<_>>()
+            .nearest(point.coords().as_slice(), count, &squared_euclidean);
+
+        if let Ok(neighbors) = result {
+            neighbors.iter().map(|(d, u)| (**u, d.sqrt())).collect()
+        } else {
+            Vec::new()
+        }
     }
 
     /// Find all points within a given radius of a point.
@@ -129,13 +147,15 @@ impl<const D: usize> KdTreeSearch<D> for KdTree<D> {
     ///
     /// ```
     fn within(&self, point: &impl PCoords<D>, radius: f64) -> Vec<(usize, f64)> {
-        let result = self
-            .tree
-            .within::<SquaredEuclidean>(&point.coords().into(), radius * radius);
-        result
-            .iter()
-            .map(|r| (r.item, r.distance.sqrt()))
-            .collect::<Vec<_>>()
+        if let Ok(result) = self.tree.within(
+            point.coords().as_slice(),
+            radius * radius,
+            &squared_euclidean,
+        ) {
+            result.iter().map(|(d, u)| (**u, d.sqrt())).collect()
+        } else {
+            Vec::new()
+        }
     }
 
     /// Get the number of points in the kd-tree.
@@ -171,7 +191,7 @@ impl<const D: usize> PartialKdTree<D> {
     /// ```
     ///
     /// ```
-    pub fn new(all_points: &[impl PCoords<D>], mask: &IndexMask) -> Self {
+    pub fn new(all_points: &[impl PCoords<D>], mask: &IndexMask) -> Result<Self> {
         if mask.len() != all_points.len() {
             panic!("Mask length must match the length of all_points");
         }
@@ -182,8 +202,8 @@ impl<const D: usize> PartialKdTree<D> {
             points.push(all_points[i].coords());
             index_map.push(i);
         }
-        let tree = KdTree::new(&points);
-        Self { tree, index_map }
+        let tree = KdTree::new(&points)?;
+        Ok(Self { tree, index_map })
     }
 }
 
@@ -193,7 +213,7 @@ impl<const D: usize> KdTreeSearch<D> for PartialKdTree<D> {
         (self.index_map[i], d)
     }
 
-    fn nearest(&self, point: &impl PCoords<D>, count: NonZero<usize>) -> Vec<(usize, f64)> {
+    fn nearest(&self, point: &impl PCoords<D>, count: usize) -> Vec<(usize, f64)> {
         let result = self.tree.nearest(point, count);
         result
             .iter()
@@ -230,7 +250,7 @@ mod tests {
             Point2::new(1.0, 1.0),
             Point2::new(2.0, 2.0),
         ];
-        let tree = KdTree::new(&points);
+        let tree = KdTree::new(&points).expect("KD tree creation failed");
         assert_eq!(tree.len(), 3);
     }
 
@@ -241,7 +261,7 @@ mod tests {
             Point2::new(1.0, 1.0),
             Point2::new(2.0, 2.0),
         ];
-        let tree = KdTree::new(&points);
+        let tree = KdTree::new(&points).expect("KD tree creation failed");
         let (i, d) = tree.nearest_one(&Point2::new(1.25, 1.25));
         assert_eq!(i, 1);
         assert_relative_eq!(d, (0.25 * 0.25 * 2.0_f64).sqrt(), epsilon = 1e-6);
@@ -254,7 +274,7 @@ mod tests {
             Point2::new(1.0, 0.0),
             Point2::new(2.0, 0.0),
         ];
-        let tree = KdTree::new(&points);
+        let tree = KdTree::new(&points).expect("KD tree creation failed");
         let within = tree.within(&Point2::new(3.5, 0.0), 2.0);
         assert_eq!(within.len(), 1);
         assert_eq!(within[0].0, 2);
@@ -267,7 +287,7 @@ mod tests {
             .flat_map(|i| (0..20).map(move |j| Point2::new(i as f64, j as f64)))
             .collect::<Vec<_>>();
 
-        let fixed_tree = KdTree::new(&points);
+        let fixed_tree = KdTree::new(&points).expect("KD tree creation failed");
 
         for _ in 0..1000 {
             let mut test_select = index_vec(None, points.len());
@@ -280,7 +300,7 @@ mod tests {
             }
             let indices = mask.to_indices();
 
-            let partial_tree = PartialKdTree::new(&points, &mask);
+            let partial_tree = PartialKdTree::new(&points, &mask).expect("KD tree creation failed");
 
             for &i in indices.iter() {
                 let p = &points[i];

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/points.rs

@@ -1,9 +1,26 @@
 //! Common operations on f64 points in D-dimensional space.
 
 use crate::common::PCoords;
+use crate::common::kd_tree::{KdTree, KdTreeSearch};
 use crate::common::surface_point::SurfacePoint;
 use parry3d_f64::na::{AbstractRotation, Isometry, Point, SVector};
-use crate::common::kd_tree::{KdTree, KdTreeSearch};
+
+pub fn area<const D: usize>(
+    pa: &impl PCoords<D>,
+    pb: &impl PCoords<D>,
+    pc: &impl PCoords<D>,
+) -> f64 {
+    let ab = pb.coords() - pa.coords();
+    let ac = pc.coords() - pa.coords();
+
+    if D == 2 {
+        0.5 * (ab[0] * ac[1] - ab[1] * ac[0]).abs()
+    } else if D == 3 {
+        0.5 * ab.cross(&ac).norm()
+    } else {
+        panic!("Area calculation is only implemented for 2D and 3D points");
+    }
+}
 
 /// Calculate the barycentric coordinates of a point `p` with respect to the triangle defined by
 /// points `a`, `b`, and `c` in D-dimensional space.  The barycentric coordinates are a way of
@@ -510,7 +527,6 @@ where
     points.iter().map(|p| transform * p).collect()
 }
 
-
 /// Clusters a set of points by distance tolerance, where all points reachable by a series of hops
 /// less than or equal to the specified tolerance are grouped together into a single cluster.
 ///
@@ -534,7 +550,8 @@ pub fn cluster_points_by_tol<const D: usize>(
     while !working.is_empty() {
         let mut group = vec![working.pop().unwrap()];
         loop {
-            let tree = KdTree::new(&group);
+            let tree =
+                KdTree::new(&group).expect("KD tree construction failed. Are there enough points?");
             let mut to_add = Vec::new();
             for (i, p) in working.iter().enumerate() {
                 // let (d, _) = tree.nearest_one(&to_slice(p), &squared_euclidean);
@@ -566,7 +583,6 @@ pub fn merge_points_by_tol<const D: usize>(
     clusters.iter().map(|c| mean_point(c)).collect()
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

{engeom-0.2.15 → engeom-0.2.16}/engeom/src/common/poisson_disk.rs

@@ -24,7 +24,8 @@ pub fn sample_poisson_disk_all<const D: usize>(
     radius: f64,
 ) -> IndexMask {
     let pre_mask = voxel_downsample(points, radius * 0.25);
-    let partial_tree = PartialKdTree::new(points, &pre_mask);
+    let partial_tree = PartialKdTree::new(points, &pre_mask)
+        .expect("KD tree construction failed. Are there enough points?");
 
     let mut skip_mask = pre_mask.clone();
     let mut final_mask = IndexMask::new(points.len(), false);
@@ -71,7 +72,7 @@ mod tests {
 
             // Brute force check that each point only has one point (itself) within the radius
             let kept = keep.clone_indices_of(&points).unwrap();
-            let tree = KdTree::new(&kept);
+            let tree = KdTree::new(&kept).expect("Tree construction failed");
             for (i, &p) in kept.iter().enumerate() {
                 let within = tree.within(&p, r);
                 assert_eq!(within.len(), 1);