Rename Point2D to Vec2 and Point3D to Vec3

Author: ictrobot

crates/utils/src/point.rs renamed to crates/utils/src/geometry.rs

@@ -1,10 +1,10 @@
-//! 2D & 3D point implementations.
+//! 2D & 3D vector implementations.
 
 use crate::number::{Integer, Number, Signed, UnsignedInteger};
 use std::fmt::Debug;
 use std::ops::{Add, AddAssign, Mul, MulAssign, Sub, SubAssign};
 
-macro_rules! point_impl {
+macro_rules! vec_impl {
     ($n:literal, $tuple:tt =>
         $(#[$m:meta])* $v:vis struct $s:ident{$($i:tt => $f:ident),+}
     ) => {
@@ -42,7 +42,7 @@ macro_rules! point_impl {
                 T::Unsigned::ZERO $(+ self.$f.abs_diff(rhs.$f))+
             }
 
-            /// Add the provided signed point, wrapping on overflow.
+            /// Add the provided signed vector, wrapping on overflow.
             ///
             /// Useful for adding a signed direction onto an unsigned position.
             #[inline]
@@ -145,12 +145,13 @@ macro_rules! point_impl {
     };
 }
 
-point_impl! {2, (T, T) =>
-    /// Struct representing a 2D point or vector.
-    pub struct Point2D{0 => x, 1 => y}
+vec_impl! {2, (T, T) =>
+    /// Struct representing a 2D vector or point.
+    #[doc(alias("Vector", "Vector2", "Point", "Point2", "Point2D"))]
+    pub struct Vec2{0 => x, 1 => y}
 }
 
-impl<T: Signed> Point2D<T> {
+impl<T: Signed> Vec2<T> {
     pub const UP: Self = Self {
         x: T::ZERO,
         y: T::ONE,
@@ -189,7 +190,8 @@ impl<T: Signed> Point2D<T> {
     }
 }
 
-point_impl! {3, (T, T, T) =>
-    /// Struct representing a 3D point or vector.
-    pub struct Point3D{0 => x, 1 => y, 2 => z}
+vec_impl! {3, (T, T, T) =>
+    /// Struct representing a 3D vector or point.
+    #[doc(alias("Vector3", "Point3", "Point3D"))]
+    pub struct Vec3{0 => x, 1 => y, 2 => z}
 }

crates/utils/src/lib.rs

@@ -5,6 +5,7 @@ pub mod array;
 pub mod bit;
 pub mod date;
 mod framework;
+pub mod geometry;
 pub mod graph;
 pub mod grid;
 pub mod input;
@@ -14,7 +15,6 @@ pub mod multithreading;
 pub mod multiversion;
 pub mod number;
 pub mod parser;
-pub mod point;
 pub mod simd;
 #[cfg(target_family = "wasm")]
 pub mod wasm;

crates/year2015/src/day03.rs

@@ -1,11 +1,11 @@
 use std::collections::HashSet;
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Counting unique points.
 #[derive(Clone, Debug)]
 pub struct Day03 {
-    directions: Vec<Point2D<i32>>,
+    directions: Vec<Vec2<i32>>,
 }
 
 impl Day03 {
@@ -14,19 +14,19 @@ impl Day03 {
             directions: input
                 .chars()
                 .map(|c| match c {
-                    '^' => Ok(Point2D::UP),
-                    '>' => Ok(Point2D::RIGHT),
-                    'v' => Ok(Point2D::DOWN),
-                    '<' => Ok(Point2D::LEFT),
+                    '^' => Ok(Vec2::UP),
+                    '>' => Ok(Vec2::RIGHT),
+                    'v' => Ok(Vec2::DOWN),
+                    '<' => Ok(Vec2::LEFT),
                     _ => Err(InputError::new(input, c, "expected one of ^>v<")),
                 })
-                .collect::<Result<Vec<Point2D<i32>>, InputError>>()?,
+                .collect::<Result<Vec<Vec2<i32>>, InputError>>()?,
         })
     }
 
     #[must_use]
     pub fn part1(&self) -> usize {
-        let mut pos = Point2D::default();
+        let mut pos = Vec2::default();
 
         self.count_positions(|dir| {
             pos += dir;
@@ -45,9 +45,9 @@ impl Day03 {
         })
     }
 
-    fn count_positions(&self, mut f: impl FnMut(Point2D<i32>) -> Point2D<i32>) -> usize {
+    fn count_positions(&self, mut f: impl FnMut(Vec2<i32>) -> Vec2<i32>) -> usize {
         let mut set = HashSet::with_capacity(self.directions.len());
-        set.insert(Point2D::default());
+        set.insert(Vec2::default());
 
         for &dir in &self.directions {
             set.insert(f(dir));

crates/year2016/src/day01.rs

@@ -1,5 +1,5 @@
 use std::collections::HashSet;
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Calculating Manhattan distance.
@@ -26,8 +26,8 @@ impl Day01 {
 
     #[must_use]
     pub fn part1(&self) -> u32 {
-        let mut pos = Point2D::ORIGIN;
-        let mut dir = Point2D::UP;
+        let mut pos = Vec2::ORIGIN;
+        let mut dir = Vec2::UP;
 
         for &(turn, steps) in &self.instructions {
             dir = match turn {
@@ -42,8 +42,8 @@ impl Day01 {
 
     #[must_use]
     pub fn part2(&self) -> u32 {
-        let mut pos: Point2D<i32> = Point2D::ORIGIN;
-        let mut dir = Point2D::UP;
+        let mut pos: Vec2<i32> = Vec2::ORIGIN;
+        let mut dir = Vec2::UP;
         let mut visited = HashSet::new();
 
         for &(turn, steps) in &self.instructions {

crates/year2016/src/day13.rs

@@ -1,5 +1,5 @@
 use std::collections::{HashSet, VecDeque};
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Finding the shortest path.
@@ -12,18 +12,18 @@ pub struct Day13 {
 impl Day13 {
     pub fn new(input: &str, input_type: InputType) -> Result<Self, InputError> {
         let favorite_number = parser::u32().parse_complete(input)?;
-        let target: Point2D<u32> = if input_type == InputType::Real {
-            Point2D::new(31, 39)
+        let target: Vec2<u32> = if input_type == InputType::Real {
+            Vec2::new(31, 39)
         } else {
-            Point2D::new(7, 4)
+            Vec2::new(7, 4)
         };
 
         // Use a hashset to store visited nodes to avoid having a fixed grid size, as theoretically
         // the shortest route to the target may first go a long way down/right.
         let mut visited = HashSet::new();
-        visited.insert(Point2D::new(1, 1));
+        visited.insert(Vec2::new(1, 1));
         let mut queue = VecDeque::new();
-        queue.push_back((Point2D::new(1, 1), 0));
+        queue.push_back((Vec2::new(1, 1), 0));
 
         let (mut part1, mut part2) = (0, 0);
         while let Some((p, steps)) = queue.pop_front() {
@@ -37,11 +37,11 @@ impl Day13 {
                 break;
             }
 
-            for next @ Point2D { x, y } in [
-                Point2D::new(p.x.saturating_sub(1), p.y),
-                Point2D::new(p.x.saturating_add(1), p.y),
-                Point2D::new(p.x, p.y.saturating_sub(1)),
-                Point2D::new(p.x, p.y.saturating_add(1)),
+            for next @ Vec2 { x, y } in [
+                Vec2::new(p.x.saturating_sub(1), p.y),
+                Vec2::new(p.x.saturating_add(1), p.y),
+                Vec2::new(p.x, p.y.saturating_sub(1)),
+                Vec2::new(p.x, p.y.saturating_add(1)),
             ] {
                 let n = (x * x) + (3 * x) + (2 * x * y) + y + (y * y) + favorite_number;
                 if n.count_ones().is_multiple_of(2) && !visited.contains(&next) {

crates/year2016/src/day22.rs

@@ -1,4 +1,4 @@
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Solving a sliding puzzle.
@@ -11,7 +11,7 @@ pub struct Day22 {
     max_x: u32,
     max_y: u32,
     wall_x: u32,
-    empty: Point2D<u32>,
+    empty: Vec2<u32>,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -100,7 +100,7 @@ impl Day22 {
         Ok(Self {
             max_x,
             max_y,
-            empty: Point2D::new(empty.x, empty.y),
+            empty: Vec2::new(empty.x, empty.y),
             wall_x,
         })
     }

crates/year2017/src/day11.rs

@@ -1,4 +1,4 @@
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Calculating distances in a hexagonal grid.
@@ -15,17 +15,17 @@ pub struct Day11 {
 impl Day11 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
         let steps = parser::literal_map!(
-            "ne" => Point2D::new(1, -1),
-            "nw" => Point2D::new(-1, 0),
-            "se" => Point2D::new(1, 0),
-            "sw" => Point2D::new(-1, 1),
-            "n" => Point2D::new(0, -1),
-            "s" => Point2D::new(0, 1),
+            "ne" => Vec2::new(1, -1),
+            "nw" => Vec2::new(-1, 0),
+            "se" => Vec2::new(1, 0),
+            "sw" => Vec2::new(-1, 1),
+            "n" => Vec2::new(0, -1),
+            "s" => Vec2::new(0, 1),
         )
         .with_suffix(b','.or(parser::eof()))
         .parse_iterator(input);
 
-        let mut pos = Point2D::new(0, 0);
+        let mut pos = Vec2::new(0, 0);
         let mut max = 0;
         for step in steps {
             pos += step?;
@@ -38,7 +38,7 @@ impl Day11 {
         })
     }
 
-    fn hex_dist_to_origin(p: Point2D<i32>) -> u32 {
+    fn hex_dist_to_origin(p: Vec2<i32>) -> u32 {
         (p.x.unsigned_abs() + (p.x + p.y).unsigned_abs() + p.y.unsigned_abs()) / 2
     }
 

crates/year2017/src/day19.rs

@@ -1,4 +1,4 @@
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Following a path.
@@ -11,7 +11,7 @@ pub struct Day19 {
 impl Day19 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
         let lines = input.lines().collect::<Vec<_>>();
-        let lookup = |p: Point2D<usize>| {
+        let lookup = |p: Vec2<usize>| {
             if p.y < lines.len() && p.x < lines[p.y].len() {
                 Some(lines[p.y].as_bytes()[p.x])
             } else {
@@ -22,8 +22,8 @@ impl Day19 {
         let Some(start_col) = lines.first().and_then(|l| l.find('|')) else {
             return Err(InputError::new(input, 0, "expected '|' on the first line"));
         };
-        let mut pos = Point2D::new(start_col, 0);
-        let mut dir = Point2D::new(0, 1);
+        let mut pos = Vec2::new(start_col, 0);
+        let mut dir = Vec2::new(0, 1);
 
         let mut letters = String::new();
         let mut steps = 1;

crates/year2017/src/day20.rs

@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use utils::point::Point3D;
+use utils::geometry::Vec3;
 use utils::prelude::*;
 
 /// Simulating colliding particles.
@@ -10,14 +10,14 @@ pub struct Day20 {
 
 #[derive(Clone, Debug)]
 struct Particle {
-    position: Point3D<i64>,
-    velocity: Point3D<i64>,
-    acceleration: Point3D<i64>,
+    position: Vec3<i64>,
+    velocity: Vec3<i64>,
+    acceleration: Vec3<i64>,
 }
 
 impl Day20 {
     pub fn new(input: &str, _: InputType) -> Result<Self, InputError> {
-        let vector = parser::i64().repeat_n(b',').map(Point3D::from);
+        let vector = parser::i64().repeat_n(b',').map(Vec3::from);
 
         Ok(Self {
             particles: vector
@@ -79,7 +79,7 @@ impl Day20 {
 }
 
 impl Particle {
-    fn position_at_time(&self, time: u64) -> Point3D<i64> {
+    fn position_at_time(&self, time: u64) -> Vec3<i64> {
         self.position
             + (self.velocity * time as i64)
             + (self.acceleration * (time as i64 * time as i64 / 2))

crates/year2018/src/day06.rs

@@ -1,10 +1,10 @@
-use utils::point::Point2D;
+use utils::geometry::Vec2;
 use utils::prelude::*;
 
 /// Measuring regions using Manhattan distance.
 #[derive(Clone, Debug)]
 pub struct Day06 {
-    locations: Vec<Point2D<usize>>,
+    locations: Vec<Vec2<usize>>,
     region_threshold: u32,
 }
 
@@ -14,7 +14,7 @@ impl Day06 {
     pub fn new(input: &str, input_type: InputType) -> Result<Self, InputError> {
         let locations = parser::number_range(0..=999)
             .repeat_n(", ")
-            .map(Point2D::from)
+            .map(Vec2::from)
             .parse_lines(input)?;
         if locations.is_empty() {
             return Err(InputError::new(input, 0, "expected at least one location"));
@@ -29,9 +29,9 @@ impl Day06 {
             return Err(InputError::new(input, 0, "coordinate range too large"));
         }
 
-        let min_point = Point2D::new(min, min);
+        let min_loc = Vec2::new(min, min);
         Ok(Self {
-            locations: locations.into_iter().map(|p| p - min_point).collect(),
+            locations: locations.into_iter().map(|p| p - min_loc).collect(),
             region_threshold: match input_type {
                 InputType::Example => 32,
                 InputType::Real => 10000,