Fix tests

Author: radevgit

src/arc.rs

@@ -1,13 +1,12 @@
 #![allow(dead_code)]
 
-use std::fmt::Display;
 
 use crate::Arc;
 
-
+// A series of contiguous arc segments.
 pub struct ArcString(pub Vec<Arc>);
 
-
+// https://github.com/georust/geo/blob/main/geo-types/src/geometry/line_string.rs
 pub struct ArcsIter<'a>(::core::slice::Iter<'a, Arc>);
 
 impl<'a> Iterator for ArcsIter<'a> {
@@ -35,12 +34,12 @@ impl<'a> DoubleEndedIterator for ArcsIter<'a> {
 }
 
 impl ArcString {
-    
+    /// Instantiate Self from the raw content value
     pub fn new(value: Vec<Arc>) -> Self {
         Self(value)
     }
 
-    
+    /// Return an iterator yielding the arcs
     pub fn arcs(&self) -> ArcsIter {
         ArcsIter(self.0.iter())
     }
@@ -53,8 +52,6 @@ impl ArcString {
 
 #[cfg(test)]
 mod test_arc_string {
-    use super::*;
-    use crate::point::point;
 
     #[test]
     fn test_new() {}

src/arc_string.rs

@@ -1,12 +1,12 @@
 #![allow(dead_code)]
 
 use crate::int_line_arc::LineArcConfig;
+use crate::line::line;
 use crate::{
-    dist_point_arc::distance_point_arc, int_arc_arc::intersect_arc_arc, int_line_arc::intersect_line_arc, point::point, Arc, Point
+    dist_point_arc::distance_point_arc, int_arc_arc::intersect_arc_arc,
+    int_line_arc::intersect_line_arc, point::point, Arc, Point,
 };
-use crate::line::line;
 
-// TODO: fake distance
 pub fn distance_arc_arc(arc0: &Arc, arc1: &Arc) -> (Point, f64) {
     let inter = intersect_arc_arc(arc0, arc1);
     match inter {
@@ -16,15 +16,15 @@ pub fn distance_arc_arc(arc0: &Arc, arc1: &Arc) -> (Point, f64) {
             v.push(distance_point_arc(arc0.b, arc1).1);
             v.push(distance_point_arc(arc1.a, arc0).1);
             v.push(distance_point_arc(arc1.b, arc0).1);
-            // Arc - Arc
+
             let la0 = intersect_line_arc(line(arc0.c, arc1.c), arc0);
             let la1 = intersect_line_arc(line(arc0.c, arc1.c), arc1);
             match (la0, la1) {
-                (LineArcConfig::OnePoint(p0, _), LineArcConfig::OnePoint(p1,_)) => {
-                    v.push((p0-p1).norm_imp());
+                (LineArcConfig::OnePoint(p0, _), LineArcConfig::OnePoint(p1, _)) => {
+                    v.push((p0 - p1).norm());
                 }
                 _ => {}
-            }            
+            }
 
             let mm;
             let m = v.into_iter().min_by(|a, b| a.partial_cmp(b).unwrap());
@@ -44,7 +44,6 @@ pub fn distance_arc_arc(arc0: &Arc, arc1: &Arc) -> (Point, f64) {
 
 #[cfg(test)]
 mod tests_distance_arc_arc {
-    
 
     #[test]
     fn test_distance_arc_arc() {}

src/dist_arc_arc.rs

@@ -1,7 +1,5 @@
 #![allow(dead_code)]
 
-use core::num;
-
 use crate::circle::Circle;
 use crate::line::Line;
 use crate::point::point;
@@ -13,45 +11,13 @@ pub enum DistLineCircleConfig {
     TwoPairs(f64, Point, Point, Point, Point),
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 pub fn distance_line_circle(line: &Line, circle: &Circle) -> DistLineCircleConfig {
     let mut parameter: [f64; 2] = [0.0; 2];
     let mut closest: [[Point; 2]; 2] = [[point(0.0, 0.0); 2]; 2];
     let num_closest_pairs;
-    
-    
-    let delta = line.origin - circle.c;
-
-    
-    
 
-    
-    
+    let delta = line.origin - circle.c;
 
-    
-    
-    
-    
-    
-    
-    
-    
     const ZERO: f64 = 0.0;
     let direction = line.dir;
     let radius = circle.r;
@@ -62,42 +28,22 @@ pub fn distance_line_circle(line: &Line, circle: &Circle) -> DistLineCircleConfi
     let r_sqr = radius * radius;
     let test = dot_perp_dir_del * dot_perp_dir_del - r_sqr * dot_dir_dir;
     if test >= ZERO {
-        
-        
-        
-        
-        
-        
-        
-        
-        
-
-        
         num_closest_pairs = 1;
         parameter[0] = -dot_dir_del / dot_dir_dir;
         closest[0][0] = delta + direction * parameter[0];
         closest[0][1] = closest[0][0];
 
-        
         if test > ZERO {
             closest[0][1].normalize();
             closest[0][1] = closest[0][1] * radius;
         }
     } else {
-        
-
-        
-        
-        
-        
         let a0 = delta.dot(delta) - radius * radius;
         let a1 = dot_dir_del;
         let a2 = dot_dir_dir;
         let discr = max(a1 * a1 - a0 * a2, ZERO);
         let sqrt_discr = discr.sqrt();
 
-        
-        
         let temp = -dot_dir_del
             + if dot_dir_del > ZERO {
                 -sqrt_discr
@@ -111,28 +57,30 @@ pub fn distance_line_circle(line: &Line, circle: &Circle) -> DistLineCircleConfi
             (parameter[1], parameter[0]) = (parameter[0], parameter[1]);
         }
 
-        
         closest[0][0] = delta + direction * parameter[0];
         closest[0][1] = closest[0][0];
         closest[1][0] = delta + direction * parameter[1];
         closest[1][1] = closest[1][0];
     }
 
-    
-    
     for j in 0..num_closest_pairs {
         for i in 0..2 {
             closest[j][i] = closest[j][i] + circle.c;
         }
     }
 
-    let diff = closest[0][0] - closest[0][1];
-    let distance = (closest[0][0] - closest[0][1]).norm_imp();
+    let distance = (closest[0][0] - closest[0][1]).norm();
 
     if num_closest_pairs == 2 {
         DistLineCircleConfig::OnePair(distance, closest[0][0], closest[0][1])
     } else {
-        DistLineCircleConfig::TwoPairs(distance, closest[0][0], closest[0][1], closest[1][0], closest[1][1])
+        DistLineCircleConfig::TwoPairs(
+            distance,
+            closest[0][0],
+            closest[0][1],
+            closest[1][0],
+            closest[1][1],
+        )
     }
 }
 
@@ -153,7 +101,6 @@ fn max(a: f64, b: f64) -> f64 {
 
 #[cfg(test)]
 mod tests_distance_line_circle {
-    use super::*;
 
     #[test]
     fn test_distance_line_circle() {}

src/dist_line_circle.rs

@@ -1,20 +1,11 @@
 #![allow(dead_code)]
 
-use crate::{
-    circle::{circle, Circle},
-    dist_point_circle::distance_point_circle,
-    Arc, Point,
-};
-
+use crate::{circle::circle, dist_point_circle::distance_point_circle, Arc, Point};
 
 pub fn distance_point_arc(point: Point, arc: &Arc) -> (Point, f64) {
     let circle = circle(arc.c, arc.r);
     let pc_result = distance_point_circle(point, &circle);
     if circle.r != pc_result.1 {
-        
-        
-        
-        
         if arc.contains(pc_result.0) {
             (pc_result.0, pc_result.1)
         } else {
@@ -29,15 +20,12 @@ pub fn distance_point_arc(point: Point, arc: &Arc) -> (Point, f64) {
             }
         }
     } else {
-        
         (arc.a, arc.r)
     }
 }
 
 #[cfg(test)]
 mod tests_dist_point_circle {
-    use super::*;
-
     #[test]
     fn test_dist_point_circle() {}
 }

src/dist_point_arc.rs

@@ -3,10 +3,9 @@
 use crate::circle::Circle;
 use crate::Point;
 
-
 pub fn distance_point_circle(point: Point, circle: &Circle) -> (Point, f64) {
     let diff = point - circle.c;
-    let length = diff.norm_imp();
+    let length = diff.norm();
     if length > 0f64 {
         let diff = diff / length;
         (circle.c + diff * circle.r, (length - circle.r).abs())
@@ -18,7 +17,6 @@ pub fn distance_point_circle(point: Point, circle: &Circle) -> (Point, f64) {
 
 #[cfg(test)]
 mod tests_distance_point_circle {
-    use super::*;
 
     #[test]
     fn test_distance_point_circle() {}

src/dist_point_circle.rs

@@ -1,21 +1,9 @@
 #![allow(dead_code)]
 
-use crate::circle::Circle;
 use crate::segment::Segment;
 use crate::Point;
 
-
-
-
-
-
-
-
-
-
 pub fn distance_point_segment(point: Point, segment: Segment) -> (Point, f64) {
-    
-    
     let closest;
     const ZERO: f64 = 0f64;
     const ONE: f64 = 1f64;
@@ -40,12 +28,11 @@ pub fn distance_point_segment(point: Point, segment: Segment) -> (Point, f64) {
         }
     }
 
-    (closest, (point - closest).norm_imp())
+    (closest, (point - closest).norm())
 }
 
 #[cfg(test)]
 mod tests_distance_point_segment {
-    use super::*;
 
     #[test]
     fn test_distance_point_segment() {}

src/dist_point_segment.rs

@@ -1,17 +1,10 @@
 #![allow(dead_code)]
 
 use crate::{
-    circle::{circle, Circle},
-    dist_point_arc::distance_point_arc,
-    dist_point_circle::distance_point_circle,
-    dist_point_segment::distance_point_segment,
-    int_segment_arc::intersect_segment_arc,
-    point::point,
-    segment::Segment,
-    Arc, Point,
+    dist_point_arc::distance_point_arc, dist_point_segment::distance_point_segment,
+    int_segment_arc::intersect_segment_arc, point::point, segment::Segment, Arc, Point,
 };
 
-
 pub fn distance_segment_arc(seg: Segment, arc: &Arc) -> (Point, f64) {
     let inter = intersect_segment_arc(seg, arc);
     match inter {
@@ -39,7 +32,6 @@ pub fn distance_segment_arc(seg: Segment, arc: &Arc) -> (Point, f64) {
 
 #[cfg(test)]
 mod tests_distance_segment_arc {
-    use super::*;
 
     #[test]
     fn test_distance_segment_arc() {}

src/dist_segment_arc.rs

@@ -1,12 +1,6 @@
 #![allow(dead_code)]
 
-use crate::int_interval_interval::{intersect_interval_interval, IntervalConfig};
-use crate::int_line_circle::LineCircleConfig;
-use crate::interval::interval;
-use crate::line::line;
-use crate::{circle::Circle, int_line_circle::intersect_line_circle, segment::Segment, Point};
-
-
+use crate::Point;
 
 #[derive(Debug, PartialEq)]
 pub enum DistSegmentCircleConfig {
@@ -15,33 +9,9 @@ pub enum DistSegmentCircleConfig {
     TwoPoints(Point, Point, f64, f64),
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-pub fn dist_segment_circle(seg: Segment, circle: Circle) -> DistSegmentCircleConfig {
-
-
-    DistSegmentCircleConfig::NoIntersection()
-}
-
-
 #[cfg(test)]
 mod tests_dist_segment_circle {
-    use super::*;
 
     #[test]
     fn test_dist_segment_circle() {}
-}
+}