vector2d 3.1.1

//! # vector2d
//! A simple and convenient 2D vector library without excessive use of external
//! dependencies. If other vector crates are swiss-army knives, vector2d is a
//! spoon; safe, intuitive, and convenient. As an added bonus, you won't run
//! into any excursions with the law using this library thanks to the awfully
//! permissive Unlicense.
//!
//! The only type in this crate is [`Vector2D`], which is highly generic;
//! shifting functionality depending upon the traits implemented by its internal
//! components' types.
//!
//! [`Vector2D`]: struct.Vector2D.html
//!
//! # Example
//! ```
//! use vector2d::Vector2D;
//!
//! // Vectors have fields X and Y, these can be of any type
//! let v1: Vector2D<i32> = Vector2D { x: 10, y: 5 };
//!
//! // Alternatively you can use new(..) to condense instantiation
//! let v2: Vector2D<f64> = Vector2D::new(13.0, 11.5);
//!
//! // There are two ways to cast between Vector2Ds, depending on the source
//! // and target types.
//! //
//! // If the target type has a implementation of From<SourceType>, then you
//! // can either use source.into_vec2d() or Vector2D::from_vec2d(source).
//! assert_eq!(Vector2D::new(10.0, 5.0), v1.into_vec2d());
//! assert_eq!(Vector2D::new(10.0, 5.0), Vector2D::from_vec2d(v1));
//!
//! // If there is no From or Into implementation, then you're out of luck
//! // unless you are using specific primitives, such as i32 and f64. In
//! // this case you can use specialised functions, as shown below:
//! assert_eq!(Vector2D::new(13, 11), v2.as_i32s());
//!
//! // The full list of interoperable primitives is as follows:
//! //   - i32, i64, isize
//! //   - u32, u64, usize
//! //   - f32, f64
//!
//! // As primitives generally implement From/Into for lossless casts,
//! // an as_Ts() function is not available for those types, and
//! // from(..)/into() should be favoured.
//! //
//! // Casts between signed and unsigned primitives will perform bounds
//! // checking, so casting the vector (-10.0, 2.0) to a Vector2D<u32> will
//! // result in the vector (0, 2).
//!
//! // For types with an Add and Mul implementation, the functions dot() and
//! // length_squared() are available. For access to length(), normalise(),
//! // or angle() however, you must be using either Vector2D<f32> or
//! // Vector2D<f64>.
//! let _v1_len_sq = v1.length_squared();
//! let v2_len = v2.length();
//! let v2_dir = v2.normalise();
//!
//! // Assuming the operator traits are implemented for the types involved,
//! // you can add and subtract Vector2Ds from one-another, as well as
//! // multiply and divide them with scalar values.
//! assert_eq!(v2, v2_dir * v2_len);
//! assert_eq!(Vector2D::new(23.0, 16.5),  v2 + v1.into_vec2d()) ;
//!
//! // If you feel the need to multiply or divide individual components of
//! // vectors with the same type, you can use mul_components(...) or
//! // div_components(...) provided that their types can be multiplied or
//! // divided.
//!
//! // For any Vector2D<T>, there is an implementation of
//! // From<(T, T)> and From<[T; 2]>
//! let v4: Vector2D<f64> = Vector2D::new(1.5, 2.3);
//! assert_eq!(v4, (1.5, 2.3).into());
//! assert_eq!(v4, [1.5, 2.3].into());
//!
//! // Additionally, there is an Into<(T, T)> implementation for any types
//! // that the vector components have their own Into implementations for
//! assert_eq!((1.5, 2.3), v4.into());
//!
//! // If you want the normal of a vector you can just call normal()
//! let v5 = Vector2D::new(-10.0, -2.3);
//! assert_eq!(Vector2D::new(2.3, -10.0), v5.normal());
//!
//! // You can get a vector consisting of only the horizontal or vertical
//! // component of a vector by calling horizontal() or vertical()
//! // respectively
//! let v6 = Vector2D::new(12.3, 83.2);
//! assert_eq!(Vector2D::new(12.3, 0.0), v6.horizontal());
//! assert_eq!(Vector2D::new(0.0, 83.2), v6.vertical());
//! ```

#[cfg(test)]
mod test;

use std::cmp::Ordering;
use std::ops::{
    Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
};

/// Convenience macro for implementing funcs like `as_i32s` concisely
macro_rules! fn_simple_as {
    ($func:ident, $type:ty) => {
        pub fn $func(&self) -> Vector2D<$type> {
            Vector2D {
                x: self.x as $type,
                y: self.y as $type,
            }
        }
    };
}

/// Convenience macro for implementing funcs like `as_u32s` concisely, while appropriately setting
/// a lower bound (e.g. 0.0) for the source value before the conversion is performed
macro_rules! fn_lower_bounded_as {
    ($func:ident, $dst_type:ty, $lower_bound:expr) => {
        pub fn $func(&self) -> Vector2D<$dst_type> {
            Vector2D {
                x: self.x.max($lower_bound) as $dst_type,
                y: self.y.max($lower_bound) as $dst_type,
            }
        }
    };
}

/// Convenience macro for implementing funcs like `as i32s` concisely, while appropriately setting
/// bounds (e.g. from i32::MIN to i32::MAX) for the source value before the conversion is
/// performed
macro_rules! fn_bounded_as {
    ($func:ident, $dst_type:ty, $lower_bound:expr, $upper_bound:expr) => {
        pub fn $func(&self) -> Vector2D<$dst_type> {
            Vector2D {
                x: self.x.min($upper_bound).max($lower_bound) as $dst_type,
                y: self.y.min($upper_bound).max($lower_bound) as $dst_type,
            }
        }
    };
}

/// A 2D vector, containing an `x` and a `y` component. While many types can be
/// used for a `Vector2D`'s components, the traits they implement determine
/// what functions are available.
///
/// Provided that the components implement the necessary traits, `Vector2D`s
/// can be added to or subtracted from one-another, and they can be mulitplied
/// and divided by scalar values.
///
/// There are generally two options for converting between `Vector2D` types. If
/// the internal components' type has an implementation of `Into` that targets
/// the desired type, then [`into_vec2d()`] can be called from the source object,
/// or [`from_vec2d(..)`] can be called and the source object can be provided.
///
/// If no `Into` implementation exists, then the only option is to use one of the
/// flavours of casting with `as`. These are in the form `as_types()`, and are only
/// implemented for specific types of components. An example usage would look like
/// this:
/// ```
/// use vector2d::Vector2D;
/// let f64_vector: Vector2D<f64> = Vector2D::new(10.3, 11.1);
/// let i32_vector: Vector2D<i32> = f64_vector.as_i32s();
/// assert_eq!(Vector2D::new(10, 11), i32_vector);
/// ```
///
/// Implementations of `as_types()` are only available when an implementation of
/// [`into_vec2d()`] is unavailable. This is to seperate between the lossless casting
/// of primitives with `into()` and `from(..)`, and the lossy casting between
/// primitives of varying detail.
///
/// Casts from signed types to unsigned types have a small additional check that
/// ensures a lower bound of 0 on the signed value, to reduce the chances of
/// experiencing undefined behaviour. This means that a `Vector2D<f64>` with a
/// value of `(-10.3, 11.1)` would become `(0, 11)` when cast to a `Vector2D<u32>`
/// with [`as_u32s()`].
///
/// The current list of interoperable types that can be cast with the `as` family of
/// functions is as follows:
///   - `i32`
///   - `i64`,
///   - `isize`
///   - `u32`
///   - `u64`
///   - `usize`
///   - `f32`
///   - `f64`
///
/// [`into_vec2d()`]: struct.Vector2D.html#method.into_vec2d
/// [`from_vec2d(..)`]: struct.Vector2D.html#method.from_vec2d
/// [`as_u32s()`]: struct.Vector2D.html#method.as_u32s-1
#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
pub struct Vector2D<T> {
    pub x: T,
    pub y: T,
}

impl<T: Copy + Clone> Vector2D<T> {
    /// Create a new `Vector2D` with the provided components.
    pub const fn new(x: T, y: T) -> Self {
        Self { x, y }
    }

    /// Convert a `Vector2` of type `U` to one of type `T`. Available only when
    /// type T has implemented `From<U>`.
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let i32_vector: Vector2D<i32> = Vector2D::new(25, 8);
    /// let f64_vector: Vector2D<f64> = Vector2D::from_vec2d(i32_vector);
    /// assert_eq!(Vector2D::new(25.0, 8.0), f64_vector);
    /// ```
    pub fn from_vec2d<U: Into<T> + Copy + Clone>(src: Vector2D<U>) -> Vector2D<T> {
        Vector2D {
            x: src.x.into(),
            y: src.y.into(),
        }
    }

    /// Convert a `Vector2` of type `T` to one of type `U`. Available only when
    /// type T has implemented `Into<U>`.
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let i32_vector: Vector2D<i32> = Vector2D::new(25, 8);
    /// let i32_vector: Vector2D<i32> = Vector2D::new(25, 8);
    /// let f64_vector: Vector2D<f64> = i32_vector.into_vec2d();
    /// assert_eq!(Vector2D::new(25.0, 8.0), f64_vector);
    /// ```
    pub fn into_vec2d<U: From<T>>(self) -> Vector2D<U> {
        Vector2D {
            x: self.x.into(),
            y: self.y.into(),
        }
    }
}

impl<T> Default for Vector2D<T>
where
    T: Default,
{
    fn default() -> Self {
        Self {
            x: T::default(),
            y: T::default(),
        }
    }
}

impl<T: Default> Vector2D<T> {
    /// Returns a vector with only the horizontal component of the current one
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let v = Vector2D::new(10, 20);
    /// assert_eq!(Vector2D::new(10, 0), v.horizontal());
    /// ```
    pub fn horizontal(self) -> Self {
        Self {
            x: self.x,
            y: Default::default(),
        }
    }

    /// Returns a vector with only the vertical component of the current one
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let v = Vector2D::new(10, 20);
    /// assert_eq!(Vector2D::new(0, 20), v.vertical());
    pub fn vertical(self) -> Self {
        Self {
            x: Default::default(),
            y: self.y,
        }
    }
}

impl<T> Vector2D<T>
where
    T: Mul<T, Output = T> + Copy + Clone,
{
    /// Returns a new vector with components equal to each of the current vector's
    /// components multiplied by the corresponding component of the provided vector
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let v1 = Vector2D::new(11.0, -2.5);
    /// let v2 = Vector2D::new(0.5, -2.0);
    /// assert_eq!(Vector2D::new(5.5, 5.0), v1.mul_components(v2));
    /// ```
    pub fn mul_components(self, other: Self) -> Self {
        Self {
            x: self.x * other.x,
            y: self.y * other.y,
        }
    }
}

impl<T> Vector2D<T>
where
    T: Div<T, Output = T> + Copy + Clone,
{
    /// Returns a new vector with components equal to each of the current vector's
    /// components divided by the corresponding component of the provided vector
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let v1 = Vector2D::new(11.0, -2.5);
    /// let v2 = Vector2D::new(0.5, -2.0);
    /// assert_eq!(Vector2D::new(22.0, 1.25), v1.div_components(v2));
    /// ```
    pub fn div_components(self, other: Self) -> Self {
        Self {
            x: self.x / other.x,
            y: self.y / other.y,
        }
    }
}

impl<T, U> Neg for Vector2D<T>
where
    T: Neg<Output = U> + Copy + Clone,
{
    type Output = Vector2D<U>;
    fn neg(self) -> Self::Output {
        Self::Output {
            x: -self.x,
            y: -self.y,
        }
    }
}

impl<T> Vector2D<T>
where
    T: Neg<Output = T> + Copy + Clone,
{
    /// Returns a vector perpendicular to the current one.
    ///
    /// # Example
    /// ```
    /// use vector2d::Vector2D;
    /// let v = Vector2D::new(21.3, -98.1);
    /// assert_eq!(Vector2D::new(98.1, 21.3), v.normal());
    /// ```
    pub fn normal(self) -> Self {
        Self {
            x: -self.y,
            y: self.x,
        }
    }
}

impl<T, U, V> Vector2D<T>
where
    T: Mul<T, Output = U> + Copy + Clone,
    U: Add<U, Output = V> + Copy + Clone,
{
    /// Get the scalar/dot product of the two `Vector2D`.
    pub fn dot(v1: Self, v2: Self) -> V {
        v1.x * v2.x + v1.y * v2.y
    }

    /// Get the squared length of a `Vector2D`. This is more performant than using
    /// `length()` -- which is only available for `Vector2D<f32>` and `Vector2D<f64>`
    /// -- as it does not perform any square root operation.
    pub fn length_squared(self) -> V {
        self.x * self.x + self.y * self.y
    }
}

impl<T> Vector2D<T>
where
    T: Sub<T, Output = T> + Mul<T, Output = T> + Add<T, Output = T> + Copy + Clone,
{
    /// Linearly interpolates between two vectors
    pub fn lerp(start: Self, end: Self, progress: T) -> Self {
        start + ((end - start) * progress)
    }
}

// From/Into Implementations

impl<T, U> From<Vector2D<T>> for (U, U)
where
    U: From<T> + Copy + Clone,
{
    fn from(src: Vector2D<T>) -> (U, U) {
        (U::from(src.x), U::from(src.y))
    }
}

impl<T, U> From<(U, U)> for Vector2D<T>
where
    T: From<U>,
    U: Copy + Clone,
{
    fn from(src: (U, U)) -> Vector2D<T> {
        Vector2D {
            x: src.0.into(),
            y: src.1.into(),
        }
    }
}

impl<T, U> From<[U; 2]> for Vector2D<T>
where
    T: From<U>,
    U: Copy + Clone,
{
    fn from(src: [U; 2]) -> Vector2D<T> {
        Vector2D {
            x: src[0].into(),
            y: src[1].into(),
        }
    }
}

impl<T> Index<usize> for Vector2D<T> {
    type Output = T;

    /// Only possible for `idx` in {0, 1} - panics otherwise
    fn index(&self, idx: usize) -> &Self::Output {
        match idx {
            0 => &self.x,
            1 => &self.y,
            _ => panic!("Index '{}' was out of range for Vector2D", idx),
        }
    }
}

impl<T> IndexMut<usize> for Vector2D<T> {
    /// Only possible for `idx` in {0, 1} - panics otherwise
    fn index_mut(&mut self, idx: usize) -> &mut Self::Output {
        match idx {
            0 => &mut self.x,
            1 => &mut self.y,
            _ => panic!("Index '{}' was out of range for Vector2D", idx),
        }
    }
}

// Specific Primitive Implementations

impl Vector2D<f32> {
    /// Get the length of the vector. If possible, favour `length_squared()` over
    /// this function, as it is more performant.
    pub fn length(self) -> f32 {
        f32::sqrt(self.length_squared())
    }

    /// Get a new vector with the same direction as this vector, but with a length
    /// of 1.0. If the the length of the vector is 0, then the original vector is
    /// returned.
    pub fn normalise(self) -> Self {
        let len = self.length();
        if len == 0.0 {
            self
        } else {
            self / len
        }
    }

    /// Get the vector's direction in radians.
    pub fn angle(self) -> f32 {
        self.y.atan2(self.x)
    }

    fn_simple_as!(as_i32s, i32);
    fn_simple_as!(as_i64s, i64);
    fn_simple_as!(as_isizes, isize);
    fn_lower_bounded_as!(as_u32s, u32, 0.0);
    fn_lower_bounded_as!(as_u64s, u64, 0.0);
    fn_lower_bounded_as!(as_usizes, usize, 0.0);
}

impl Vector2D<f64> {
    /// Get the length of the vector. If possible, favour `length_squared()` over
    /// this function, as it is more performant.
    pub fn length(self) -> f64 {
        f64::sqrt(self.length_squared())
    }

    /// Get a new vector with the same direction as this vector, but with a length
    /// of 1.0. If the the length of the vector is 0, then the original vector is
    /// returned.
    pub fn normalise(self) -> Self {
        let len = self.length();
        if len == 0.0 {
            self
        } else {
            self / len
        }
    }

    /// Get the vector's direction in radians.
    pub fn angle(self) -> f64 {
        self.y.atan2(self.x)
    }

    fn_simple_as!(as_i32s, i32);
    fn_simple_as!(as_i64s, i64);
    fn_simple_as!(as_isize, isize);
    fn_simple_as!(as_f32, f32);
    fn_lower_bounded_as!(as_u32s, u32, 0.0);
    fn_lower_bounded_as!(as_u64s, u64, 0.0);
    fn_lower_bounded_as!(as_usizes, usize, 0.0);
}

impl Vector2D<i32> {
    fn_simple_as!(as_isizes, isize);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_lower_bounded_as!(as_u32s, u32, 0);
    fn_lower_bounded_as!(as_u64s, u64, 0);
    fn_lower_bounded_as!(as_usizes, usize, 0);
}

impl Vector2D<i64> {
    fn_bounded_as!(as_i32s, i32, i32::MIN.into(), i32::MAX.into());
    fn_simple_as!(as_i64s, isize);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_lower_bounded_as!(as_u32s, u32, 0);
    fn_lower_bounded_as!(as_u64s, u64, 0);
    fn_lower_bounded_as!(as_usizes, usize, 0);
}

impl Vector2D<isize> {
    fn_simple_as!(as_i32s, i32);
    fn_simple_as!(as_i64s, i64);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_lower_bounded_as!(as_u32s, u32, 0);
    fn_lower_bounded_as!(as_u64s, u64, 0);
    fn_lower_bounded_as!(as_usizes, usize, 0);
}

impl Vector2D<u32> {
    fn_bounded_as!(as_i32s, i32, 0, i32::MAX as u32);
    fn_simple_as!(as_i64s, i64);
    fn_simple_as!(as_isizes, isize);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_simple_as!(as_usizes, usize);
}

impl Vector2D<u64> {
    fn_bounded_as!(as_i32s, i32, 0, i32::MAX as u64);
    fn_bounded_as!(as_i64s, i64, 0, i64::MAX as u64);
    fn_simple_as!(as_isizes, isize);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_simple_as!(as_u32s, u32);
    fn_simple_as!(as_usizes, usize);
}

impl Vector2D<usize> {
    fn_simple_as!(as_i32s, i32);
    fn_simple_as!(as_i64s, i64);
    fn_bounded_as!(as_isizes, isize, 0, isize::MAX as usize);
    fn_simple_as!(as_f32s, f32);
    fn_simple_as!(as_f64s, f64);
    fn_simple_as!(as_u32s, u32);
    fn_simple_as!(as_u64s, u64);
}

///  Blanket impls for `min_each`, `max_each`, and `clamp_each`
impl<T> Vector2D<T>
where
    T: PartialOrd + Copy + Clone,
{
    // PartialOrd types don't get max, min, or clamp functions so we write our own. When comparison
    // is impossible, we just return the first arg, as v1 this is the pre-existing value inside our
    // vector and keeping it intact in such cases is somewhat reasonable enough.

    fn min_t(v1: T, v2: T) -> T {
        match v1.partial_cmp(&v2) {
            None => v1,
            Some(Ordering::Less) => v1,
            Some(_) => v2,
        }
    }

    fn max_t(v1: T, v2: T) -> T {
        match v1.partial_cmp(&v2) {
            None => v1,
            Some(Ordering::Greater) => v1,
            Some(_) => v2,
        }
    }

    fn clamp_t(v: T, min: T, max: T) -> T {
        Self::max_t(Self::min_t(v, max), min)
    }

    /// Compares each component against the provided value, and returns a new vector with the lower
    /// value in each component
    pub fn min_each(self, value: T) -> Self {
        Self {
            x: Self::min_t(self.x, value),
            y: Self::min_t(self.y, value),
        }
    }

    /// Compares each component against the provided value, and returns a new vector with the higher
    /// value in each component
    pub fn max_each(self, value: T) -> Self {
        Self {
            x: Self::max_t(self.x, value),
            y: Self::max_t(self.y, value),
        }
    }

    /// Returns a new vector where each component has the values of the source vector clamped within
    /// the provided bounds
    pub fn clamp_each(self, min: T, max: T) -> Self {
        Self {
            x: Self::clamp_t(self.x, min, max),
            y: Self::clamp_t(self.y, min, max),
        }
    }
}

// Ops Implementations

impl<T, O> Add<Vector2D<T>> for Vector2D<T>
where
    T: Add<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn add(self, rhs: Vector2D<T>) -> Self::Output {
        Vector2D {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
        }
    }
}

impl<T, O> Add<&Vector2D<T>> for &Vector2D<T>
where
    T: Add<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn add(self, rhs: &Vector2D<T>) -> Self::Output {
        Vector2D {
            x: self.x + rhs.x,
            y: self.y + rhs.y,
        }
    }
}

impl<T> AddAssign<Vector2D<T>> for Vector2D<T>
where
    T: Add<T, Output = T> + Copy + Clone,
{
    fn add_assign(&mut self, rhs: Vector2D<T>) {
        self.x = self.x + rhs.x;
        self.y = self.y + rhs.y;
    }
}

impl<T, O> Sub<Vector2D<T>> for Vector2D<T>
where
    T: Sub<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn sub(self, rhs: Vector2D<T>) -> Self::Output {
        Vector2D {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
        }
    }
}

impl<T, O> Sub<&Vector2D<T>> for &Vector2D<T>
where
    T: Sub<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn sub(self, rhs: &Vector2D<T>) -> Self::Output {
        Vector2D {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
        }
    }
}

impl<T> SubAssign<Vector2D<T>> for Vector2D<T>
where
    T: Sub<T, Output = T> + Copy + Clone,
{
    fn sub_assign(&mut self, rhs: Vector2D<T>) {
        self.x = self.x - rhs.x;
        self.y = self.y - rhs.y;
    }
}

impl<T, O> Mul<T> for Vector2D<T>
where
    T: Mul<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn mul(self, rhs: T) -> Self::Output {
        Vector2D {
            x: self.x * rhs,
            y: self.y * rhs,
        }
    }
}

impl<T, O> Mul<T> for &Vector2D<T>
where
    T: Mul<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn mul(self, rhs: T) -> Self::Output {
        Self::Output {
            x: self.x * rhs,
            y: self.y * rhs,
        }
    }
}

impl<T> MulAssign<T> for Vector2D<T>
where
    T: Mul<T, Output = T> + Copy + Clone,
{
    fn mul_assign(&mut self, rhs: T) {
        self.x = self.x * rhs;
        self.y = self.y * rhs;
    }
}

impl<T, O> Div<T> for Vector2D<T>
where
    T: Div<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn div(self, rhs: T) -> Self::Output {
        Self::Output {
            x: self.x / rhs,
            y: self.y / rhs,
        }
    }
}

impl<T, O> Div<T> for &Vector2D<T>
where
    T: Div<T, Output = O> + Copy + Clone,
{
    type Output = Vector2D<O>;
    fn div(self, rhs: T) -> Self::Output {
        Self::Output {
            x: self.x / rhs,
            y: self.y / rhs,
        }
    }
}

impl<T> DivAssign<T> for Vector2D<T>
where
    T: Div<T, Output = T> + Copy + Clone,
{
    fn div_assign(&mut self, rhs: T) {
        self.x = self.x / rhs;
        self.y = self.y / rhs;
    }
}