physdes/

vector2.rs

// #![no_std]

#[cfg(any(test, feature = "std"))]
// #[cfg_attr(test, macro_use)]
// extern crate std;

// use core::fmt;
#[cfg(test)]
use core::hash;
// use core::iter::{Product, Sum};
use core::ops::{Add, Div, Mul, Neg, Rem, Sub};

// use core::str::FromStr;
#[cfg(feature = "std")]
use std::error::Error;

use num_traits::{Num, Signed, Zero};

/// The code defines a generic struct called Vector2 with two fields, x_ and y_.
///
/// Properties:
///
/// * `x_`: The `x_` property represents the x-coordinate of the Vector2 object. It is of type `T`,
/// which means it can be any type specified when creating an instance of the Vector2 struct.
/// * `y_`: The `y_` property is the y-coordinate of the `Vector2` object. It represents the vertical
/// position of the vector in a 2D coordinate system.
#[derive(PartialEq, Eq, Copy, Clone, Hash, Debug, Default)]
// #[repr(C)]
pub struct Vector2<T> {
    /// x portion of the Vector2 object
    pub x_: T,
    /// y portion of the Vector2 object
    pub y_: T,
}

impl<T> Vector2<T> {
    /// The function `new` creates a new Vector2 with the given x and y values.
    ///
    /// Arguments:
    ///
    /// * `x_`: The parameter `x_` represents the x-coordinate of the Vector2.
    /// * `y_`: The parameter `y_` represents the y-coordinate of the Vector2. It is of type `T`, which
    /// means it can be any type that is specified when the Vector2 is created.
    ///
    /// Returns:
    ///
    /// The `new` function is returning a new instance of the `Vector2` struct with the provided `x_`
    /// and `y_` values.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2), Vector2 { x_: 1, y_: 2 });
    /// assert_eq!(Vector2::new(3, 4), Vector2 { x_: 3, y_: 4 });
    /// ```
    #[inline]
    pub const fn new(x_: T, y_: T) -> Self {
        Vector2 { x_, y_ }
    }
}

impl<T: Clone + Num> Vector2<T> {
    /// The `dot` function calculates the dot product of two vectors.
    ///
    /// Arguments:
    ///
    /// * `other`: The `other` parameter is of the same type as `self`, which means it is an instance of
    /// the same struct or class that the `dot` method is defined in.
    ///
    /// Returns:
    ///
    /// The dot product of two vectors is being returned.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).dot(&Vector2::new(3, 4)), 11);
    /// assert_eq!(Vector2::new(3, 4).dot(&Vector2::new(1, 2)), 11);
    /// ```
    #[inline]
    pub fn dot(&self, other: &Self) -> T {
        self.x_.clone() * other.x_.clone() + self.y_.clone() * other.y_.clone()
    }

    /// The `cross` function calculates the cross product of two vectors.
    ///
    /// Arguments:
    ///
    /// * `other`: The `other` parameter is of type `Self`, which means it is the same type as the
    /// current object.
    ///
    /// Returns:
    ///
    /// The cross product of two vectors is being returned.
    /// Returns the cross product
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).cross(&Vector2::new(3, 4)), -2);
    /// assert_eq!(Vector2::new(3, 4).cross(&Vector2::new(1, 2)), 2);
    /// ```
    #[inline]
    pub fn cross(&self, other: &Self) -> T {
        self.x_.clone() * other.y_.clone() - self.y_.clone() * other.x_.clone()
    }

    /// The `norm_sqr` function calculates the square of the norm of a vector.
    ///
    /// Returns:
    ///
    /// The `norm_sqr` function returns the squared norm of the object on which it is called.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).norm_sqr(), 5);
    /// assert_eq!(Vector2::new(3, 4).norm_sqr(), 25);
    /// ```
    #[inline]
    pub fn norm_sqr(&self) -> T {
        self.dot(self)
    }

    /// The `scale` function multiplies the vector by a scalar value.
    ///
    /// Arguments:
    ///
    /// * `t`: The parameter `t` is a scalar value that will be used to multiply each component of
    /// `self`.
    ///
    /// Returns:
    ///
    /// The `scale` method returns a new instance of the same type as `self`.
    /// Multiplies `self` by the scalar `t`.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).scale(3), Vector2::new(3, 6));
    /// assert_eq!(Vector2::new(3, 4).scale(2), Vector2::new(6, 8));
    /// ```
    #[inline]
    pub fn scale(&self, t: T) -> Self {
        Self::new(self.x_.clone() * t.clone(), self.y_.clone() * t)
    }

    /// The `unscale` function divides the coordinates of a vector by a scalar value.
    ///
    /// Arguments:
    ///
    /// * `t`: The parameter `t` is a scalar value that is used to divide the `self` object. It is of
    /// type `T`, which is a generic type parameter. The division operation is performed on the `x_` and
    /// `y_` fields of the `self` object.
    ///
    /// Returns:
    ///
    /// The `unscale` method returns a new instance of the same type as `self`.
    /// Divides `self` by the scalar `t`.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(3, 6).unscale(3), Vector2::new(1, 2));
    /// assert_eq!(Vector2::new(6, 8).unscale(2), Vector2::new(3, 4));
    /// ```
    #[inline]
    pub fn unscale(&self, t: T) -> Self {
        Self::new(self.x_.clone() / t.clone(), self.y_.clone() / t)
    }
}

impl<T: Clone + Signed> Vector2<T> {
    /// The `l1_norm` function calculates the Manhattan distance from the origin.
    ///
    /// [Manhattan distance]: https://en.wikipedia.org/wiki/Taxicab_geometry
    ///
    /// Returns:
    ///
    /// The L1 norm, which is the Manhattan distance from the origin.
    /// Returns the L1 norm `|x_| + |y_|` -- the [Manhattan distance] from the origin.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).l1_norm(), 3);
    /// assert_eq!(Vector2::new(3, 4).l1_norm(), 7);
    /// ```
    #[inline]
    pub fn l1_norm(&self) -> T {
        self.x_.abs() + self.y_.abs()
    }
}

impl<T: Clone + PartialOrd> Vector2<T> {
    /// The `norm_inf` function returns the maximum absolute value between `x_` and `y_`.
    ///
    /// Returns:
    ///
    /// The `norm_inf` function returns the maximum value between `|x_|` and `|y_|`.
    /// Returns the infinity norm `max(|x_| + |y_|)`
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    ///
    /// assert_eq!(Vector2::new(1, 2).norm_inf(), 2);
    /// assert_eq!(Vector2::new(3, 4).norm_inf(), 4);
    /// ```
    #[inline]
    pub fn norm_inf(&self) -> T {
        if self.x_ > self.y_ {
            self.x_.clone()
        } else {
            self.y_.clone()
        }
    }
}

macro_rules! forward_xf_xf_binop {
    (impl $imp:ident, $method:ident) => {
        impl<'a, 'b, T: Clone + Num> $imp<&'b Vector2<T>> for &'a Vector2<T> {
            type Output = Vector2<T>;

            /// The function clones the input arguments and calls the specified method on them.
            ///
            /// Arguments:
            ///
            /// * `other`: A reference to another Vector2 object of the same type as self.
            #[inline]
            fn $method(self, other: &Vector2<T>) -> Self::Output {
                self.clone().$method(other.clone())
            }
        }
    };
}

macro_rules! forward_xf_val_binop {
    (impl $imp:ident, $method:ident) => {
        impl<'a, T: Clone + Num> $imp<Vector2<T>> for &'a Vector2<T> {
            type Output = Vector2<T>;

            #[inline]
            fn $method(self, other: Vector2<T>) -> Self::Output {
                self.clone().$method(other)
            }
        }
    };
}

macro_rules! forward_val_xf_binop {
    (impl $imp:ident, $method:ident) => {
        impl<'a, T: Clone + Num> $imp<&'a Vector2<T>> for Vector2<T> {
            type Output = Vector2<T>;

            #[inline]
            fn $method(self, other: &Vector2<T>) -> Self::Output {
                self.$method(other.clone())
            }
        }
    };
}

macro_rules! forward_all_binop {
    (impl $imp:ident, $method:ident) => {
        forward_xf_xf_binop!(impl $imp, $method);
        forward_xf_val_binop!(impl $imp, $method);
        forward_val_xf_binop!(impl $imp, $method);
    };
}

// arithmetic
forward_all_binop!(impl Add, add);

// (a, b) + (c, d) == (a + c), (b + d)
impl<T: Clone + Num> Add<Vector2<T>> for Vector2<T> {
    type Output = Self;

    /// The function `add` takes two values of the same type and returns their sum.
    ///
    /// Arguments:
    ///
    /// * `other`: The `other` parameter is of the same type as `self` and represents the other object
    /// that you want to add to `self`.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    /// use std::ops::Add;
    ///
    /// assert_eq!(Vector2::new(1, 2).add(Vector2::new(3, 4)), Vector2::new(4, 6));
    /// assert_eq!(Vector2::new(3, 4).add(Vector2::new(1, 2)), Vector2::new(4, 6));
    /// ```
    #[inline]
    fn add(self, other: Self) -> Self::Output {
        Self::Output::new(self.x_ + other.x_, self.y_ + other.y_)
    }
}

forward_all_binop!(impl Sub, sub);

// (a, b) - (c, d) == (a - c), (b - d)
impl<T: Clone + Num> Sub<Vector2<T>> for Vector2<T> {
    type Output = Self;

    /// The function subtracts the coordinates of two points and returns a new point.
    ///
    /// Arguments:
    ///
    /// * `other`: The `other` parameter is of the same type as `self` and represents the other value
    /// that you want to subtract from `self`.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    /// use std::ops::Sub;
    ///
    /// assert_eq!(Vector2::new(1, 2).sub(Vector2::new(3, 4)), Vector2::new(-2, -2));
    /// assert_eq!(Vector2::new(3, 4).sub(Vector2::new(1, 2)), Vector2::new(2, 2));
    /// ```
    #[inline]
    fn sub(self, other: Self) -> Self::Output {
        Self::Output::new(self.x_ - other.x_, self.y_ - other.y_)
    }
}

// Op Assign

mod opassign {
    use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};

    use num_traits::NumAssign;

    use crate::Vector2;

    impl<T: Clone + NumAssign> AddAssign for Vector2<T> {
        /// The function `add_assign` adds the values of `other.x_` and `other.y_` to `self.x_` and
        /// `self.y_` respectively.
        ///
        /// Arguments:
        ///
        /// * `other`: The "other" parameter is of type Self, which means it is a reference to another
        /// instance of the same struct or class that the method is defined in. In this case, it
        /// represents another instance of the struct or class that has the same fields or properties as
        /// self.
        ///
        /// # Example
        ///
        /// ```
        /// use physdes::vector2::Vector2;
        /// use std::ops::AddAssign;
        ///
        /// let mut v = Vector2::new(1, 2);
        /// let v2 = Vector2::new(3, 4);
        /// v.add_assign(v2);
        /// assert_eq!(v, Vector2::new(4, 6));
        /// ```
        fn add_assign(&mut self, other: Self) {
            self.x_ += other.x_;
            self.y_ += other.y_;
        }
    }

    impl<T: Clone + NumAssign> SubAssign for Vector2<T> {
        /// The function subtracts the values of another object from the values of the current object.
        ///
        /// Arguments:
        ///
        /// * `other`: The parameter "other" is of type Self, which means it is a reference to another
        /// instance of the same struct or class that the method is defined in. In this case, it is a
        /// reference to another instance of the struct or class that has the same fields as self (x_
        /// and y
        ///
        /// # Example
        ///
        /// ```
        /// use physdes::vector2::Vector2;
        /// use std::ops::SubAssign;
        /// let mut v = Vector2::new(1, 2);
        /// let v2 = Vector2::new(3, 4);
        /// v.sub_assign(v2);
        /// assert_eq!(v, Vector2::new(-2, -2));
        /// ```
        fn sub_assign(&mut self, other: Self) {
            self.x_ -= other.x_;
            self.y_ -= other.y_;
        }
    }

    impl<T: Clone + NumAssign> MulAssign<T> for Vector2<T> {
        /// The function multiplies the values of self.x_ and self.y_ by the value of other.
        ///
        /// Arguments:
        ///
        /// * `other`: The parameter `other` is of type `T`, which means it can be any type that
        /// implements the `Clone` trait.
        ///
        /// # Example
        ///
        /// ```
        /// use physdes::vector2::Vector2;
        /// use std::ops::MulAssign;
        ///
        /// let mut v = Vector2::new(1, 2);
        /// v.mul_assign(3);
        /// assert_eq!(v, Vector2::new(3, 6));
        /// ```
        fn mul_assign(&mut self, other: T) {
            self.x_ *= other.clone();
            self.y_ *= other;
        }
    }

    impl<T: Clone + NumAssign> DivAssign<T> for Vector2<T> {
        /// The function divides the values of self.x_ and self.y_ by the value of other.
        ///
        /// Arguments:
        ///
        /// * `other`: The parameter `other` is of type `T`, which means it can be any type that
        /// implements the `Clone` trait.
        ///
        /// # Example
        ///
        /// ```
        /// use physdes::vector2::Vector2;
        /// use std::ops::DivAssign;
        ///
        /// let mut v = Vector2::new(3, 6);
        /// v.div_assign(3);
        /// assert_eq!(v, Vector2::new(1, 2));
        /// ```
        fn div_assign(&mut self, other: T) {
            self.x_ /= other.clone();
            self.y_ /= other;
        }
    }

    macro_rules! forward_op_assign1 {
        (impl $imp:ident, $method:ident) => {
            impl<'a, T: Clone + NumAssign> $imp<&'a Vector2<T>> for Vector2<T> {
                #[inline]
                fn $method(&mut self, other: &Self) {
                    self.$method(other.clone())
                }
            }
        };
    }

    macro_rules! forward_op_assign2 {
        (impl $imp:ident, $method:ident) => {
            impl<'a, T: Clone + NumAssign> $imp<&'a T> for Vector2<T> {
                #[inline]
                fn $method(&mut self, other: &T) {
                    self.$method(other.clone())
                }
            }
        };
    }

    forward_op_assign1!(impl AddAssign, add_assign);
    forward_op_assign1!(impl SubAssign, sub_assign);
    forward_op_assign2!(impl MulAssign, mul_assign);
    forward_op_assign2!(impl DivAssign, div_assign);
}

impl<T: Clone + Num + Neg<Output = T>> Neg for Vector2<T> {
    type Output = Self;

    /// The `neg` function returns a new instance of the same type with the negated values of `x_` and
    /// `y_`.
    ///
    /// # Example
    ///
    /// ```
    /// use physdes::vector2::Vector2;
    /// use std::ops::Neg;
    ///
    /// let v = Vector2::new(1, 2);
    /// assert_eq!(-v, Vector2::new(-1, -2));
    /// ```
    #[inline]
    fn neg(self) -> Self::Output {
        Self::Output::new(-self.x_, -self.y_)
    }
}

impl<'a, T: Clone + Num + Neg<Output = T>> Neg for &'a Vector2<T> {
    type Output = Vector2<T>;

    #[inline]
    fn neg(self) -> Self::Output {
        -self.clone()
    }
}

macro_rules! scalar_arithmetic {
    (@forward $imp:ident::$method:ident for $($scalar:ident),*) => (
        impl<'a, T: Clone + Num> $imp<&'a T> for Vector2<T> {
            type Output = Vector2<T>;

            #[inline]
            fn $method(self, other: &T) -> Self::Output {
                self.$method(other.clone())
            }
        }
        impl<'a, T: Clone + Num> $imp<T> for &'a Vector2<T> {
            type Output = Vector2<T>;

            #[inline]
            fn $method(self, other: T) -> Self::Output {
                self.clone().$method(other)
            }
        }
        impl<'a, 'b, T: Clone + Num> $imp<&'a T> for &'b Vector2<T> {
            type Output = Vector2<T>;

            #[inline]
            fn $method(self, other: &T) -> Self::Output {
                self.clone().$method(other.clone())
            }
        }
        $(
            impl<'a> $imp<&'a Vector2<$scalar>> for $scalar {
                type Output = Vector2<$scalar>;

                #[inline]
                fn $method(self, other: &Vector2<$scalar>) -> Vector2<$scalar> {
                    self.$method(other.clone())
                }
            }
            impl<'a> $imp<Vector2<$scalar>> for &'a $scalar {
                type Output = Vector2<$scalar>;

                #[inline]
                fn $method(self, other: Vector2<$scalar>) -> Vector2<$scalar> {
                    self.clone().$method(other)
                }
            }
            impl<'a, 'b> $imp<&'a Vector2<$scalar>> for &'b $scalar {
                type Output = Vector2<$scalar>;

                #[inline]
                fn $method(self, other: &Vector2<$scalar>) -> Vector2<$scalar> {
                    self.clone().$method(other.clone())
                }
            }
        )*
    );
    ($($scalar:ident),*) => (
        scalar_arithmetic!(@forward Mul::mul for $($scalar),*);
        // scalar_arithmetic!(@forward Div::div for $($scalar),*);
        // scalar_arithmetic!(@forward Rem::rem for $($scalar),*);

        $(
            impl Mul<Vector2<$scalar>> for $scalar {
                type Output = Vector2<$scalar>;

                #[inline]
                fn mul(self, other: Vector2<$scalar>) -> Self::Output {
                    Self::Output::new(self * other.x_, self * other.y_)
                }
            }

        )*
    );
}

impl<T: Clone + Num> Mul<T> for Vector2<T> {
    type Output = Vector2<T>;

    #[inline]
    fn mul(self, other: T) -> Self::Output {
        Self::Output::new(self.x_ * other.clone(), self.y_ * other)
    }
}

impl<T: Clone + Num> Div<T> for Vector2<T> {
    type Output = Self;

    #[inline]
    fn div(self, other: T) -> Self::Output {
        Self::Output::new(self.x_ / other.clone(), self.y_ / other)
    }
}

impl<T: Clone + Num> Rem<T> for Vector2<T> {
    type Output = Vector2<T>;

    #[inline]
    fn rem(self, other: T) -> Self::Output {
        Self::Output::new(self.x_ % other.clone(), self.y_ % other)
    }
}

scalar_arithmetic!(usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64);

// constants
impl<T: Clone + Num> Zero for Vector2<T> {
    #[inline]
    fn zero() -> Self {
        Self::new(Zero::zero(), Zero::zero())
    }

    #[inline]
    fn is_zero(&self) -> bool {
        self.x_.is_zero() && self.y_.is_zero()
    }

    #[inline]
    fn set_zero(&mut self) {
        self.x_.set_zero();
        self.y_.set_zero();
    }
}

#[cfg(test)]
fn hash<T: hash::Hash>(x: &T) -> u64 {
    use std::collections::hash_map::RandomState;
    use std::hash::{BuildHasher, Hasher};
    let mut hasher = <RandomState as BuildHasher>::Hasher::new();
    x.hash(&mut hasher);
    hasher.finish()
}

#[cfg(test)]
mod test {
    #![allow(non_upper_case_globals)]

    use super::{hash, Vector2};
    use core::f64;
    use num_traits::Zero;

    pub const _0_0v: Vector2<f64> = Vector2 { x_: 0.0, y_: 0.0 };
    pub const _1_0v: Vector2<f64> = Vector2 { x_: 1.0, y_: 0.0 };
    pub const _1_1v: Vector2<f64> = Vector2 { x_: 1.0, y_: 1.0 };
    pub const _0_1v: Vector2<f64> = Vector2 { x_: 0.0, y_: 1.0 };
    pub const _neg1_1v: Vector2<f64> = Vector2 { x_: -1.0, y_: 1.0 };
    pub const _05_05v: Vector2<f64> = Vector2 { x_: 0.5, y_: 0.5 };
    pub const all_consts: [Vector2<f64>; 5] = [_0_0v, _1_0v, _1_1v, _neg1_1v, _05_05v];
    pub const _4_2v: Vector2<f64> = Vector2 { x_: 4.0, y_: 2.0 };

    #[test]
    fn test_consts() {
        // check our constants are what Vector2::new creates
        fn test(c: Vector2<f64>, r: f64, i: f64) {
            assert_eq!(c, Vector2::new(r, i));
        }
        test(_0_0v, 0.0, 0.0);
        test(_1_0v, 1.0, 0.0);
        test(_1_1v, 1.0, 1.0);
        test(_neg1_1v, -1.0, 1.0);
        test(_05_05v, 0.5, 0.5);
        assert_eq!(_0_0v, Zero::zero());
    }

    #[test]
    fn test_scale_unscale() {
        assert_eq!(_05_05v.scale(2.0), _1_1v);
        assert_eq!(_1_1v.unscale(2.0), _05_05v);
        for &c in all_consts.iter() {
            assert_eq!(c.scale(2.0).unscale(2.0), c);
        }
    }

    #[test]
    fn test_hash() {
        let a = Vector2::new(0i32, 0i32);
        let b = Vector2::new(1i32, 0i32);
        let c = Vector2::new(0i32, 1i32);
        assert!(hash(&a) != hash(&b));
        assert!(hash(&b) != hash(&c));
        assert!(hash(&c) != hash(&a));
    }
}