#[macro_export]
macro_rules! point {
( $x:expr, $y:expr ) => {
- Point2D { x: $x, y: $y }
+ Point { x: $x, y: $y }
};
}
#[derive(Debug, Default, Copy, Clone, PartialEq)]
-pub struct Point2D<T> {
+pub struct Point<T> {
pub x: T,
pub y: T,
}
-impl Point2D<f64> {
+impl Point<f64> {
pub fn length(&self) -> f64 {
((self.x * self.x) + (self.y * self.y)).sqrt()
}
self.to_radians().to_degrees()
}
- pub fn to_i32(self) -> Point2D<i32> {
- Point2D {
+ pub fn to_i32(self) -> Point<i32> {
+ Point {
x: self.x as i32,
y: self.y as i32,
}
macro_rules! point_op {
($op:tt, $trait:ident($fn:ident), $trait_assign:ident($fn_assign:ident), $rhs:ident = $Rhs:ty => $x:expr, $y:expr) => {
- impl<T: $trait<Output = T>> $trait<$Rhs> for Point2D<T> {
+ impl<T: $trait<Output = T>> $trait<$Rhs> for Point<T> {
type Output = Self;
fn $fn(self, $rhs: $Rhs) -> Self {
}
}
- impl<T: $trait<Output = T> + Copy> $trait_assign<$Rhs> for Point2D<T> {
+ impl<T: $trait<Output = T> + Copy> $trait_assign<$Rhs> for Point<T> {
fn $fn_assign(&mut self, $rhs: $Rhs) {
*self = Self {
x: self.x $op $x,
}
}
-point_op!(+, Add(add), AddAssign(add_assign), rhs = Point2D<T> => rhs.x, rhs.y);
-point_op!(-, Sub(sub), SubAssign(sub_assign), rhs = Point2D<T> => rhs.x, rhs.y);
-point_op!(*, Mul(mul), MulAssign(mul_assign), rhs = Point2D<T> => rhs.x, rhs.y);
-point_op!(/, Div(div), DivAssign(div_assign), rhs = Point2D<T> => rhs.x, rhs.y);
+point_op!(+, Add(add), AddAssign(add_assign), rhs = Point<T> => rhs.x, rhs.y);
+point_op!(-, Sub(sub), SubAssign(sub_assign), rhs = Point<T> => rhs.x, rhs.y);
+point_op!(*, Mul(mul), MulAssign(mul_assign), rhs = Point<T> => rhs.x, rhs.y);
+point_op!(/, Div(div), DivAssign(div_assign), rhs = Point<T> => rhs.x, rhs.y);
point_op!(+, Add(add), AddAssign(add_assign), rhs = (T, T) => rhs.0, rhs.1);
point_op!(-, Sub(sub), SubAssign(sub_assign), rhs = (T, T) => rhs.0, rhs.1);
point_op!(*, Mul(mul), MulAssign(mul_assign), rhs = (T, T) => rhs.0, rhs.1);
point_op!(/, Div(div), DivAssign(div_assign), rhs = (T, T) => rhs.0, rhs.1);
////////// multiply point with scalar //////////////////////////////////////////
-impl<T: Mul<Output = T> + Copy> Mul<T> for Point2D<T> {
+impl<T: Mul<Output = T> + Copy> Mul<T> for Point<T> {
type Output = Self;
fn mul(self, rhs: T) -> Self {
}
}
-impl<T: Mul<Output = T> + Copy> MulAssign<T> for Point2D<T> {
+impl<T: Mul<Output = T> + Copy> MulAssign<T> for Point<T> {
fn mul_assign(&mut self, rhs: T) {
*self = Self {
x: self.x * rhs,
}
////////// divide point with scalar ////////////////////////////////////////////
-impl<T: Div<Output = T> + Copy> Div<T> for Point2D<T> {
+impl<T: Div<Output = T> + Copy> Div<T> for Point<T> {
type Output = Self;
fn div(self, rhs: T) -> Self {
}
}
-impl<T: Div<Output = T> + Copy> DivAssign<T> for Point2D<T> {
+impl<T: Div<Output = T> + Copy> DivAssign<T> for Point<T> {
fn div_assign(&mut self, rhs: T) {
*self = Self {
x: self.x / rhs,
}
}
-impl<T: Neg<Output = T>> Neg for Point2D<T> {
+impl<T: Neg<Output = T>> Neg for Point<T> {
type Output = Self;
fn neg(self) -> Self {
}
}
-impl<T> From<(T, T)> for Point2D<T> {
+impl<T> From<(T, T)> for Point<T> {
fn from(item: (T, T)) -> Self {
- Point2D {
+ Point {
x: item.0,
y: item.1,
}
}
}
-impl<T> From<Point2D<T>> for (T, T) {
- fn from(item: Point2D<T>) -> Self {
+impl<T> From<Point<T>> for (T, T) {
+ fn from(item: Point<T>) -> Self {
(item.x, item.y)
}
}
-impl From<Degrees> for Point2D<f64> {
+impl From<Degrees> for Point<f64> {
fn from(item: Degrees) -> Self {
let r = item.0.to_radians();
- Point2D {
+ Point {
x: r.cos(),
y: r.sin(),
}
}
}
-impl From<Radians> for Point2D<f64> {
+impl From<Radians> for Point<f64> {
fn from(item: Radians) -> Self {
- Point2D {
+ Point {
x: item.0.cos(),
y: item.0.sin(),
}
assert_eq!(Radians(0.0).to_degrees(), Degrees(0.0));
assert_eq!(Radians(std::f64::consts::PI).to_degrees(), Degrees(180.0));
assert_eq!(Degrees(180.0).to_radians(), Radians(std::f64::consts::PI));
- assert!((Point2D::from(Degrees(90.0)) - point!(0.0, 1.0)).length() < 0.001);
- assert!((Point2D::from(Radians(std::f64::consts::FRAC_PI_2)) - point!(0.0, 1.0)).length() < 0.001);
+ assert!((Point::from(Degrees(90.0)) - point!(0.0, 1.0)).length() < 0.001);
+ assert!((Point::from(Radians(std::f64::consts::FRAC_PI_2)) - point!(0.0, 1.0)).length() < 0.001);
}
#[test]