aoc/util/
point.rs

1//! Comprehensive 2 dimensional point implementation. This class is designed to work together
2//! with the [`Grid`] class.
3//!
4//! A common theme in Advent of Code is operations in 2 dimensions. This module provides a
5//! [`Point`] struct along with implementations of several of the [`std::ops`] traits to support
6//! operator overloading, that allows shorthand expressions such as:
7//!
8//! ```
9//!   # use aoc::util::point::Point;
10//!
11//!   let a = Point::new(1, 2);
12//!   let b = Point::new(3, 4);
13//!   let k = 2;
14//!
15//!   assert_eq!(a + b, Point::new(4, 6));
16//!   assert_eq!(a - b, Point::new(-2, -2));
17//!   assert_eq!(a * k, Point::new(2, 4));
18//! ```
19//!
20//! Additionally there are [`clockwise`] and [`counter_clockwise`] functions for 90 degree rotations
21//! and a [`manhattan`] function for the
22//! [Manhattan distance](https://en.wikipedia.org/wiki/Taxicab_geometry) between 2 points.
23//!
24//! [`clockwise`]: Point::clockwise
25//! [`counter_clockwise`]: Point::counter_clockwise
26//! [`manhattan`]: Point::manhattan
27//! [`Grid`]: crate::util::grid
28use std::hash::{Hash, Hasher};
29use std::ops::{Add, AddAssign, Mul, Sub, SubAssign};
30
31pub const ORIGIN: Point = Point::new(0, 0);
32pub const UP: Point = Point::new(0, -1);
33pub const DOWN: Point = Point::new(0, 1);
34pub const LEFT: Point = Point::new(-1, 0);
35pub const RIGHT: Point = Point::new(1, 0);
36pub const ORTHOGONAL: [Point; 4] = [UP, DOWN, LEFT, RIGHT];
37// Left to right and top to bottom.
38pub const DIAGONAL: [Point; 8] = [
39    Point::new(-1, -1),
40    UP,
41    Point::new(1, -1),
42    LEFT,
43    RIGHT,
44    Point::new(-1, 1),
45    DOWN,
46    Point::new(1, 1),
47];
48
49#[derive(Copy, Clone, Debug, Eq, PartialEq)]
50pub struct Point {
51    pub x: i32,
52    pub y: i32,
53}
54
55impl Point {
56    #[inline]
57    #[must_use]
58    pub const fn new(x: i32, y: i32) -> Self {
59        Point { x, y }
60    }
61
62    #[inline]
63    #[must_use]
64    pub fn clockwise(self) -> Self {
65        Point::new(-self.y, self.x)
66    }
67
68    #[inline]
69    #[must_use]
70    pub fn counter_clockwise(self) -> Self {
71        Point::new(self.y, -self.x)
72    }
73
74    #[inline]
75    #[must_use]
76    pub fn manhattan(self, other: Self) -> i32 {
77        (self.x - other.x).abs() + (self.y - other.y).abs()
78    }
79
80    #[inline]
81    #[must_use]
82    pub fn signum(self, other: Self) -> Self {
83        Point::new((self.x - other.x).signum(), (self.y - other.y).signum())
84    }
85}
86
87impl From<u8> for Point {
88    #[inline]
89    fn from(value: u8) -> Self {
90        match value {
91            b'^' | b'U' => UP,
92            b'v' | b'D' => DOWN,
93            b'<' | b'L' => LEFT,
94            b'>' | b'R' => RIGHT,
95            _ => unreachable!(),
96        }
97    }
98}
99
100impl Hash for Point {
101    #[inline]
102    fn hash<H: Hasher>(&self, state: &mut H) {
103        state.write_u32(self.x as u32);
104        state.write_u32(self.y as u32);
105    }
106}
107
108impl Add for Point {
109    type Output = Self;
110
111    #[inline]
112    fn add(self, rhs: Self) -> Self {
113        Point::new(self.x + rhs.x, self.y + rhs.y)
114    }
115}
116
117impl AddAssign for Point {
118    #[inline]
119    fn add_assign(&mut self, rhs: Self) {
120        self.x += rhs.x;
121        self.y += rhs.y;
122    }
123}
124
125impl Mul<i32> for Point {
126    type Output = Self;
127
128    #[inline]
129    fn mul(self, rhs: i32) -> Self {
130        Point::new(self.x * rhs, self.y * rhs)
131    }
132}
133
134impl Sub for Point {
135    type Output = Self;
136
137    #[inline]
138    fn sub(self, rhs: Self) -> Self {
139        Point::new(self.x - rhs.x, self.y - rhs.y)
140    }
141}
142
143impl SubAssign for Point {
144    #[inline]
145    fn sub_assign(&mut self, rhs: Self) {
146        self.x -= rhs.x;
147        self.y -= rhs.y;
148    }
149}
aoc/util/point.rs

aoc/util/
point.rs
