Add "new" method and SubAssign implementation

Author: maneatingape

src/util/grid.rs

@@ -7,7 +7,7 @@
 //!   # use aoc::util::point::Point;
 //!
 //!   let mut grid = Grid::parse("1");
-//!   let point = Point { x: 0, y: 0 };
+//!   let point = Point::new(0, 0);
 //!
 //!   let foo = grid[point];
 //!   assert_eq!(foo, b'1');
@@ -58,7 +58,7 @@ impl<T: Copy + PartialEq> Grid<T> {
         let to_point = |index| {
             let x = (index as i32) % self.width;
             let y = (index as i32) / self.width;
-            Point { x, y }
+            Point::new(x, y)
         };
         self.bytes.iter().position(|&h| h == needle).map(to_point)
     }

src/util/point.rs

@@ -8,13 +8,13 @@
 //! ```
 //!   # use aoc::util::point::Point;
 //!
-//!   let a = Point { x: 1, y: 2 };
-//!   let b = Point { x: 3, y: 4 };
+//!   let a = Point::new(1, 2);
+//!   let b = Point::new(3, 4);
 //!   let k = 2;
 //!
-//!   assert_eq!(a + b, Point { x: 4, y: 6 });
-//!   assert_eq!(a - b, Point { x: -2, y: -2 });
-//!   assert_eq!(a * k, Point { x: 2, y: 4 });
+//!   assert_eq!(a + b, Point::new(4, 6));
+//!   assert_eq!(a - b, Point::new(-2, -2));
+//!   assert_eq!(a * k, Point::new(2, 4));
 //! ```
 //!
 //! Additionally there are [`clockwise`] and [`counter_clockwise`] functions for 90 degree rotations
@@ -26,13 +26,13 @@
 //! [`manhattan`]: Point::manhattan
 //! [`Grid`]: crate::util::grid
 use std::hash::{Hash, Hasher};
-use std::ops::{Add, AddAssign, Mul, Sub};
+use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
 
-pub const ORIGIN: Point = Point { x: 0, y: 0 };
-pub const UP: Point = Point { x: 0, y: -1 };
-pub const DOWN: Point = Point { x: 0, y: 1 };
-pub const LEFT: Point = Point { x: -1, y: 0 };
-pub const RIGHT: Point = Point { x: 1, y: 0 };
+pub const ORIGIN: Point = Point::new(0, 0);
+pub const UP: Point = Point::new(0, -1);
+pub const DOWN: Point = Point::new(0, 1);
+pub const LEFT: Point = Point::new(-1, 0);
+pub const RIGHT: Point = Point::new(1, 0);
 pub const ORTHOGONAL: [Point; 4] = [UP, DOWN, LEFT, RIGHT];
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -41,46 +41,30 @@ pub struct Point {
     pub y: i32,
 }
 
-impl Add for Point {
-    type Output = Point;
-
+impl Point {
     #[inline]
-    fn add(self, rhs: Point) -> Point {
-        Point { x: self.x + rhs.x, y: self.y + rhs.y }
+    pub const fn new(x: i32, y: i32) -> Self {
+        Point { x, y }
     }
-}
-
-impl Sub for Point {
-    type Output = Point;
 
     #[inline]
-    fn sub(self, rhs: Point) -> Point {
-        Point { x: self.x - rhs.x, y: self.y - rhs.y }
+    pub fn clockwise(self) -> Point {
+        Point::new(-self.y, self.x)
     }
-}
-
-impl Mul<i32> for Point {
-    type Output = Point;
 
     #[inline]
-    fn mul(self, rhs: i32) -> Self::Output {
-        Point { x: self.x * rhs, y: self.y * rhs }
+    pub fn counter_clockwise(self) -> Point {
+        Point::new(self.y, -self.x)
     }
-}
 
-impl AddAssign for Point {
     #[inline]
-    fn add_assign(&mut self, rhs: Point) {
-        self.x += rhs.x;
-        self.y += rhs.y;
+    pub fn manhattan(self, other: Point) -> i32 {
+        (self.x - other.x).abs() + (self.y - other.y).abs()
     }
-}
 
-impl Hash for Point {
     #[inline]
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        hasher.write_u32(self.x as u32);
-        hasher.write_u32(self.y as u32);
+    pub fn signum(self, other: Point) -> Point {
+        Point::new((self.x - other.x).signum(), (self.y - other.y).signum())
     }
 }
 
@@ -97,24 +81,53 @@ impl From<u8> for Point {
     }
 }
 
-impl Point {
+impl Hash for Point {
     #[inline]
-    pub fn clockwise(self) -> Point {
-        Point { x: -self.y, y: self.x }
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        hasher.write_u32(self.x as u32);
+        hasher.write_u32(self.y as u32);
     }
+}
+
+impl Add for Point {
+    type Output = Point;
 
     #[inline]
-    pub fn counter_clockwise(self) -> Point {
-        Point { x: self.y, y: -self.x }
+    fn add(self, rhs: Point) -> Point {
+        Point::new(self.x + rhs.x, self.y + rhs.y)
     }
+}
 
+impl AddAssign for Point {
     #[inline]
-    pub fn manhattan(self, other: Point) -> i32 {
-        (self.x - other.x).abs() + (self.y - other.y).abs()
+    fn add_assign(&mut self, rhs: Point) {
+        self.x += rhs.x;
+        self.y += rhs.y;
     }
+}
+
+impl Mul<i32> for Point {
+    type Output = Point;
 
     #[inline]
-    pub fn signum(self, other: Point) -> Point {
-        Point { x: (self.x - other.x).signum(), y: (self.y - other.y).signum() }
+    fn mul(self, rhs: i32) -> Self::Output {
+        Point::new(self.x * rhs, self.y * rhs)
+    }
+}
+
+impl Sub for Point {
+    type Output = Point;
+
+    #[inline]
+    fn sub(self, rhs: Point) -> Point {
+        Point::new(self.x - rhs.x, self.y - rhs.y)
+    }
+}
+
+impl SubAssign for Point {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Point) {
+        self.x -= rhs.x;
+        self.y -= rhs.y;
     }
 }

src/year2019/day03.rs

@@ -90,22 +90,22 @@ pub fn parse(input: &str) -> Input {
             match direction {
                 b'U' => {
                     for (&y, line) in horizontal.range(end.y..=start.y) {
-                        update(line, Point { x: start.x, y });
+                        update(line, Point::new(start.x, y));
                     }
                 }
                 b'D' => {
                     for (&y, line) in horizontal.range(start.y..=end.y) {
-                        update(line, Point { x: start.x, y });
+                        update(line, Point::new(start.x, y));
                     }
                 }
                 b'L' => {
                     for (&x, line) in vertical.range(end.x..=start.x) {
-                        update(line, Point { x, y: start.y });
+                        update(line, Point::new(x, start.y));
                     }
                 }
                 b'R' => {
                     for (&x, line) in vertical.range(start.x..=end.x) {
-                        update(line, Point { x, y: start.y });
+                        update(line, Point::new(x, start.y));
                     }
                 }
                 _ => unreachable!(),

src/year2020/day11.rs

@@ -12,14 +12,14 @@ use std::mem::swap;
 
 const FLOOR: u8 = b'.';
 const DIRECTIONS: [Point; 8] = [
-    Point { x: -1, y: -1 },
-    Point { x: 0, y: -1 },
-    Point { x: 1, y: -1 },
-    Point { x: -1, y: 0 },
-    Point { x: 1, y: 0 },
-    Point { x: -1, y: 1 },
-    Point { x: 0, y: 1 },
-    Point { x: 1, y: 1 },
+    Point::new(-1, -1),
+    Point::new(0, -1),
+    Point::new(1, -1),
+    Point::new(-1, 0),
+    Point::new(1, 0),
+    Point::new(-1, 1),
+    Point::new(0, 1),
+    Point::new(1, 1),
 ];
 
 struct Seat {
@@ -55,7 +55,7 @@ pub fn simulate(input: &Grid<u8>, part_one: bool, limit: u8) -> u32 {
 
     for y in 0..height {
         for x in 0..width {
-            let point = Point { x, y };
+            let point = Point::new(x, y);
             if input[point] == FLOOR {
                 continue;
             }

src/year2020/day12.rs

@@ -14,7 +14,7 @@ pub fn parse(input: &str) -> Vec<Command> {
 
 pub fn part1(input: &[Command]) -> i32 {
     let mut position = ORIGIN;
-    let mut direction = Point { x: 1, y: 0 };
+    let mut direction = Point::new(1, 0);
 
     for &(command, amount) in input {
         match command {
@@ -34,7 +34,7 @@ pub fn part1(input: &[Command]) -> i32 {
 
 pub fn part2(input: &[Command]) -> i32 {
     let mut position = ORIGIN;
-    let mut waypoint = Point { x: 10, y: -1 };
+    let mut waypoint = Point::new(10, -1);
 
     for &(command, amount) in input {
         match command {

src/year2020/day17.rs

@@ -83,7 +83,7 @@ fn boot_process(input: &Grid<u8>, size: i32, base: i32, fourth_dimension: &[i32]
     // dimension. This allows six for growth, plus one for padding to prevent needing edge checks.
     for x in 0..input.width {
         for y in 0..input.height {
-            if input[Point { x, y }] == b'#' {
+            if input[Point::new(x, y)] == b'#' {
                 let index = 7 * base + x + y * stride::Y;
                 active.push(index as usize);
             }

src/year2021/day09.rs

@@ -26,7 +26,7 @@ pub fn part1(grid: &Grid<u8>) -> u32 {
 
     for x in 0..grid.width {
         for y in 0..grid.height {
-            let point = Point { x, y };
+            let point = Point::new(x, y);
             let cur = grid[point];
             let low_point = ORTHOGONAL
                 .iter()
@@ -49,7 +49,7 @@ pub fn part2(input: &Grid<u8>) -> u32 {
 
     for x in 0..grid.width {
         for y in 0..grid.height {
-            let next = Point { x, y };
+            let next = Point::new(x, y);
             if grid[next] < b'9' {
                 basins.push(flood_fill(&mut grid, next));
             }

src/year2021/day13.rs

@@ -29,7 +29,7 @@ pub struct Input {
 pub fn parse(input: &str) -> Input {
     let (prefix, suffix) = input.split_once("\n\n").unwrap();
 
-    let points: Vec<_> = prefix.iter_signed().chunk::<2>().map(|[x, y]| Point { x, y }).collect();
+    let points: Vec<_> = prefix.iter_signed().chunk::<2>().map(|[x, y]| Point::new(x, y)).collect();
 
     let folds: Vec<_> = suffix
         .lines()
@@ -103,7 +103,7 @@ fn fold_horizontal(x: i32, p: Point) -> Point {
     if p.x < x {
         p
     } else {
-        Point { x: 2 * x - p.x, y: p.y }
+        Point::new(2 * x - p.x, p.y)
     }
 }
 
@@ -113,6 +113,6 @@ fn fold_vertical(y: i32, p: Point) -> Point {
     if p.y < y {
         p
     } else {
-        Point { x: p.x, y: 2 * y - p.y }
+        Point::new(p.x, 2 * y - p.y)
     }
 }

src/year2022/day09.rs

@@ -57,7 +57,7 @@ fn simulate<const N: usize>(input: &Input) -> u32 {
     let ([x1, y1, x2, y2], pairs) = input;
     let width = x2 - x1 + 1;
     let height = y2 - y1 + 1;
-    let start = Point { x: -x1, y: -y1 };
+    let start = Point::new(-x1, -y1);
 
     let mut distinct = 0;
     let mut rope = [start; N];
@@ -70,8 +70,7 @@ fn simulate<const N: usize>(input: &Input) -> u32 {
                 if !apart(rope[i - 1], rope[i]) {
                     break;
                 }
-                let next = delta(rope[i - 1], rope[i]);
-                rope[i] += next;
+                rope[i] += rope[i - 1].signum(rope[i]);
             }
 
             let tail = rope[N - 1];
@@ -93,11 +92,3 @@ fn simulate<const N: usize>(input: &Input) -> u32 {
 fn apart(a: Point, b: Point) -> bool {
     (a.x - b.x).abs() > 1 || (a.y - b.y).abs() > 1
 }
-
-/// The [`signum`] function comes in handy to figure out the direction that knots should move.
-///
-/// [`signum`]: i32::signum
-#[inline]
-fn delta(a: Point, b: Point) -> Point {
-    Point { x: (a.x - b.x).signum(), y: (a.y - b.y).signum() }
-}

src/year2022/day15.rs

@@ -13,8 +13,8 @@ pub struct Input {
 
 pub fn parse(input: &str) -> Vec<Input> {
     fn helper([x1, y1, x2, y2]: [i32; 4]) -> Input {
-        let sensor = Point { x: x1, y: y1 };
-        let beacon = Point { x: x2, y: y2 };
+        let sensor = Point::new(x1, y1);
+        let beacon = Point::new(x2, y2);
         let manhattan = sensor.manhattan(beacon);
         Input { sensor, beacon, manhattan }
     }
@@ -112,7 +112,7 @@ pub fn part2_testable(input: &[Input], size: i32) -> u64 {
         for &&y in &horizontal {
             // Rotate intersection point counter clockwise and scale by 1 / √2
             // to return to original coordinates.
-            let point = Point { x: (x + y) / 2, y: (y - x) / 2 };
+            let point = Point::new((x + y) / 2, (y - x) / 2);
             // As we're mixing overlaps from different boxes there may some spurious false
             // positives, so double check all points are within the specified area
             // and outside the range of all scanners.