day22 finished

src/common/area.rs

@@ -3,22 +3,22 @@ use std::fmt::Display;
 
 use num_traits::{Num, NumAssignOps};
 
-use super::pos::Pos2D;
+use super::pos2::Pos2;
 
 #[derive(Debug, Clone, Copy, Default)]
 pub struct Area<T>
 where
     T: Num,
 {
-    lower_left: Pos2D<T>,
-    upper_right: Pos2D<T>,
+    lower_left: Pos2<T>,
+    upper_right: Pos2<T>,
 }
 
 impl<T> Area<T>
 where
     T: Num + Ord + Copy,
 {
-    pub fn new(p1: Pos2D<T>, p2: Pos2D<T>) -> Area<T> {
+    pub fn new(p1: Pos2<T>, p2: Pos2<T>) -> Area<T> {
         Area {
             lower_left: p1.min_components(p2),
             upper_right: p1.max_components(p2),
@@ -30,7 +30,7 @@ impl<T> Area<T>
 where
     T: Num + Ord + Copy,
 {
-    pub fn extend(&self, pos: Pos2D<T>) -> Area<T> {
+    pub fn extend(&self, pos: Pos2<T>) -> Area<T> {
         if self.contains(pos) {
             return *self;
         }
@@ -40,15 +40,15 @@ where
             upper_right: self.upper_right.max_components(pos),
         }
     }
-    pub fn get_lower_left(&self) -> Pos2D<T> {
+    pub fn get_lower_left(&self) -> Pos2<T> {
         self.lower_left
     }
 
-    pub fn get_upper_right(&self) -> Pos2D<T> {
+    pub fn get_upper_right(&self) -> Pos2<T> {
         self.upper_right
     }
 
-    pub fn contains(&self, pos: Pos2D<T>) -> bool {
+    pub fn contains(&self, pos: Pos2<T>) -> bool {
         self.lower_left.x() >= pos.x()
             && pos.x() >= self.upper_right.x()
             && self.lower_left.y() >= pos.y()
@@ -62,7 +62,7 @@ where
 {
     pub fn from_iterator<I>(mut iter: I) -> Option<Self>
     where
-        I: Iterator<Item = &'a Pos2D<T>>,
+        I: Iterator<Item = &'a Pos2<T>>,
     {
         let first = *iter.next()?;
         let (upper, lower) = iter.fold((first, first), |(mx, mn), p| {
@@ -214,12 +214,12 @@ impl<'a, T> Iterator for ColIterator<'a, T>
 where
     T: Num + Ord + NumAssignOps + Copy,
 {
-    type Item = Pos2D<T>;
+    type Item = Pos2<T>;
     fn next(&mut self) -> Option<Self::Item> {
         if (self.ascending && self.col <= self.area.upper_right.x())
             || (!self.ascending && self.col >= self.area.lower_left.x())
         {
-            let pos = Pos2D::new(self.col, self.row);
+            let pos = Pos2::new(self.col, self.row);
             if self.ascending {
                 self.col += T::one();
             } else {
@@ -266,13 +266,13 @@ impl<'a, T> Iterator for CellIterator<'a, T>
 where
     T: Num + Ord + NumAssignOps + Copy,
 {
-    type Item = Pos2D<T>;
+    type Item = Pos2<T>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if (self.ascending && self.row <= self.area.upper_right.y())
             || (!self.ascending && self.row >= self.area.lower_left.y())
         {
-            let pos = Pos2D::new(self.col, self.row);
+            let pos = Pos2::new(self.col, self.row);
             if self.ascending {
                 self.col += T::one();
                 if self.col > self.area.upper_right.x() {
@@ -300,18 +300,18 @@ mod test {
 
     #[test]
     fn test_cell_iterator() {
-        let area = Area::new(Pos2D::new(-1, -1), Pos2D::new(1, 1));
+        let area = Area::new(Pos2::new(-1, -1), Pos2::new(1, 1));
         let result = area.cells(true).collect::<Vec<_>>();
         let expected = vec![
-            Pos2D::new(-1, -1),
-            Pos2D::new(0, -1),
-            Pos2D::new(1, -1),
-            Pos2D::new(-1, 0),
-            Pos2D::new(0, 0),
-            Pos2D::new(1, 0),
-            Pos2D::new(-1, 1),
-            Pos2D::new(0, 1),
-            Pos2D::new(1, 1),
+            Pos2::new(-1, -1),
+            Pos2::new(0, -1),
+            Pos2::new(1, -1),
+            Pos2::new(-1, 0),
+            Pos2::new(0, 0),
+            Pos2::new(1, 0),
+            Pos2::new(-1, 1),
+            Pos2::new(0, 1),
+            Pos2::new(1, 1),
         ];
         assert_eq!(result, expected);
     }