askew 0.1.0

use super::Angle;

macro_rules! impl_bin_op {
    ($trait:ident, $func:ident) => {
        impl core::ops::$trait for Angle {
            type Output = Self;

            #[inline]
            fn $func(self, other: Self) -> Self::Output {
                Self {
                    radians: self.radians.$func(other.radians),
                }
            }
        }

        impl core::ops::$trait for &Angle {
            type Output = Angle;

            #[inline]
            fn $func(self, other: Self) -> Self::Output {
                Angle {
                    radians: self.radians.$func(other.radians),
                }
            }
        }

        impl<'a> core::ops::$trait<Angle> for &'a Angle {
            type Output = Angle;

            #[inline]
            fn $func(self, other: Angle) -> Self::Output {
                Angle {
                    radians: self.radians.$func(other.radians),
                }
            }
        }

        impl<'a> core::ops::$trait<&'a Angle> for Angle {
            type Output = Angle;

            #[inline]
            fn $func(self, other: &'a Angle) -> Self::Output {
                Angle {
                    radians: self.radians.$func(other.radians),
                }
            }
        }
    };
}

impl_bin_op!(Add, add);
impl_bin_op!(Sub, sub);
impl_bin_op!(Mul, mul);
impl_bin_op!(Div, div);
impl_bin_op!(Rem, rem);

macro_rules! impl_bin_assign_op {
    ($trait:ident, $func:ident) => {
        impl core::ops::$trait for Angle {
            #[inline]
            fn $func(&mut self, other: Self) {
                self.radians.$func(other.radians);
            }
        }

        impl<'a> core::ops::$trait<&'a Angle> for Angle {
            #[inline]
            fn $func(&mut self, other: &'a Angle) {
                self.radians.$func(other.radians);
            }
        }
    };
}

impl_bin_assign_op!(AddAssign, add_assign);
impl_bin_assign_op!(SubAssign, sub_assign);
impl_bin_assign_op!(MulAssign, mul_assign);
impl_bin_assign_op!(DivAssign, div_assign);
impl_bin_assign_op!(RemAssign, rem_assign);

macro_rules! impl_unary_op {
    ($trait:ident, $func:ident) => {
        impl core::ops::$trait for Angle {
            type Output = Self;

            #[inline]
            fn $func(self) -> Self::Output {
                Self {
                    radians: self.radians.$func(),
                }
            }
        }

        impl core::ops::$trait for &Angle {
            type Output = Angle;

            #[inline]
            fn $func(self) -> Self::Output {
                Angle {
                    radians: self.radians.$func(),
                }
            }
        }
    };
}

impl_unary_op!(Neg, neg);

#[cfg(test)]
#[allow(clippy::float_cmp)]
mod tests {
    use super::*;

    #[test]
    fn add_owned_owned() {
        let a = Angle::from_radians(1.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a + b, Angle::from_radians(3.0));
    }

    #[test]
    fn add_owned_ref() {
        let a = Angle::from_radians(1.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a + b, Angle::from_radians(3.0));
    }

    #[test]
    fn add_ref_owned() {
        let a = &Angle::from_radians(1.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a + b, Angle::from_radians(3.0));
    }

    #[test]
    fn add_ref_ref() {
        let a = &Angle::from_radians(1.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a + b, Angle::from_radians(3.0));
    }

    #[test]
    fn sub_owned_owned() {
        let a = Angle::from_radians(3.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a - b, Angle::from_radians(1.0));
    }

    #[test]
    fn sub_owned_ref() {
        let a = Angle::from_radians(3.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a - b, Angle::from_radians(1.0));
    }

    #[test]
    fn sub_ref_owned() {
        let a = &Angle::from_radians(3.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a - b, Angle::from_radians(1.0));
    }

    #[test]
    fn sub_ref_ref() {
        let a = &Angle::from_radians(3.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a - b, Angle::from_radians(1.0));
    }

    #[test]
    fn mul_owned_owned() {
        let a = Angle::from_radians(2.0);
        let b = Angle::from_radians(3.0);
        assert_eq!(a * b, Angle::from_radians(6.0));
    }

    #[test]
    fn mul_owned_ref() {
        let a = Angle::from_radians(2.0);
        let b = &Angle::from_radians(3.0);
        assert_eq!(a * b, Angle::from_radians(6.0));
    }

    #[test]
    fn mul_ref_owned() {
        let a = &Angle::from_radians(2.0);
        let b = Angle::from_radians(3.0);
        assert_eq!(a * b, Angle::from_radians(6.0));
    }

    #[test]
    fn mul_ref_ref() {
        let a = &Angle::from_radians(2.0);
        let b = &Angle::from_radians(3.0);
        assert_eq!(a * b, Angle::from_radians(6.0));
    }

    #[test]
    fn div_owned_owned() {
        let a = Angle::from_radians(6.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a / b, Angle::from_radians(3.0));
    }

    #[test]
    fn div_owned_ref() {
        let a = Angle::from_radians(6.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a / b, Angle::from_radians(3.0));
    }

    #[test]
    fn div_ref_owned() {
        let a = &Angle::from_radians(6.0);
        let b = Angle::from_radians(2.0);
        assert_eq!(a / b, Angle::from_radians(3.0));
    }

    #[test]
    fn div_ref_ref() {
        let a = &Angle::from_radians(6.0);
        let b = &Angle::from_radians(2.0);
        assert_eq!(a / b, Angle::from_radians(3.0));
    }

    #[test]
    fn rem_owned_owned() {
        let a = Angle::from_radians(7.0);
        let b = Angle::from_radians(3.0);
        assert_eq!(a % b, Angle::from_radians(1.0));
    }

    #[test]
    fn rem_owned_ref() {
        let a = Angle::from_radians(7.0);
        let b = &Angle::from_radians(3.0);
        assert_eq!(a % b, Angle::from_radians(1.0));
    }

    #[test]
    fn rem_ref_owned() {
        let a = &Angle::from_radians(7.0);
        let b = Angle::from_radians(3.0);
        assert_eq!(a % b, Angle::from_radians(1.0));
    }

    #[test]
    fn rem_ref_ref() {
        let a = &Angle::from_radians(7.0);
        let b = &Angle::from_radians(3.0);
        assert_eq!(a % b, Angle::from_radians(1.0));
    }

    #[test]
    fn add_assign_owned() {
        let mut a = Angle::from_radians(1.0);
        let b = Angle::from_radians(2.0);
        a += b;
        assert_eq!(a, Angle::from_radians(3.0));
    }

    #[test]
    fn add_assign_ref() {
        let mut a = Angle::from_radians(1.0);
        let b = &Angle::from_radians(2.0);
        a += b;
        assert_eq!(a, Angle::from_radians(3.0));
    }

    #[test]
    fn sub_assign_owned() {
        let mut a = Angle::from_radians(3.0);
        let b = Angle::from_radians(2.0);
        a -= b;
        assert_eq!(a, Angle::from_radians(1.0));
    }

    #[test]
    fn sub_assign_ref() {
        let mut a = Angle::from_radians(3.0);
        let b = &Angle::from_radians(2.0);
        a -= b;
        assert_eq!(a, Angle::from_radians(1.0));
    }

    #[test]
    fn mul_assign_owned() {
        let mut a = Angle::from_radians(2.0);
        let b = Angle::from_radians(3.0);
        a *= b;
        assert_eq!(a, Angle::from_radians(6.0));
    }

    #[test]
    fn mul_assign_ref() {
        let mut a = Angle::from_radians(2.0);
        let b = &Angle::from_radians(3.0);
        a *= b;
        assert_eq!(a, Angle::from_radians(6.0));
    }

    #[test]
    fn div_assign_owned() {
        let mut a = Angle::from_radians(6.0);
        let b = Angle::from_radians(2.0);
        a /= b;
        assert_eq!(a, Angle::from_radians(3.0));
    }

    #[test]
    fn div_assign_ref() {
        let mut a = Angle::from_radians(6.0);
        let b = &Angle::from_radians(2.0);
        a /= b;
        assert_eq!(a, Angle::from_radians(3.0));
    }

    #[test]
    fn rem_assign_owned() {
        let mut a = Angle::from_radians(7.0);
        let b = Angle::from_radians(3.0);
        a %= b;
        assert_eq!(a, Angle::from_radians(1.0));
    }

    #[test]
    fn rem_assign_ref() {
        let mut a = Angle::from_radians(7.0);
        let b = &Angle::from_radians(3.0);
        a %= b;
        assert_eq!(a, Angle::from_radians(1.0));
    }

    #[test]
    fn neg_owned() {
        let angle = Angle::from_radians(1.0);
        assert_eq!((-angle).as_radians(), -1.0);
    }

    #[test]
    fn neg_ref() {
        let angle = Angle::from_radians(1.0);
        assert_eq!((-&angle).as_radians(), -1.0);
    }
}