point/src/rem.rs

use crate::Point;
use std::ops::{Rem, RemAssign};
use num::Integer;

/*
P % T
P % (T, T)
P % P
P % &P
P % &mP
&P % T
&P % (T, T)
&P % P
&P % &P
&P % &mP
&mP % T
&mP % (T, T)
&mP % P
&mP % &P
&mP % &mP
P %= T
P %= (T, T)
P %= P
P %= &P
P %= &mP
*/

impl<T: Integer + Copy> Rem<T> for Point<T> {
    type Output = Self;
    fn rem(self, rhs: T) -> Self::Output {
        Self::from((self.x%rhs, self.y%rhs))
    }
}

impl<T: Integer> Rem<(T, T)> for Point<T> {
    type Output = Self;
    fn rem(self, rhs: (T, T)) -> Self::Output {
        Self::from((self.x%rhs.0, self.y%rhs.1))
    }
}

impl<T: Integer> Rem<Point<T>> for Point<T> {
    type Output = Self;
    fn rem(self, rhs: Point<T>) -> Self::Output {
        Self::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&Point<T>> for Point<T> {
    type Output = Self;
    fn rem(self, rhs: &Point<T>) -> Self::Output {
        Self::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&mut Point<T>> for Point<T> {
    type Output = Self;
    fn rem(self, rhs: &mut Point<T>) -> Self::Output {
        Self::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<T> for &Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: T) -> Self::Output {
        Point::from((self.x%rhs, self.y%rhs))
    }
}

impl<T: Integer + Copy> Rem<(T, T)> for &Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: (T, T)) -> Self::Output {
        Point::from((self.x%rhs.0, self.y%rhs.1))
    }
}

impl<T: Integer + Copy> Rem<Point<T>> for &Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&Point<T>> for &Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: &Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&mut Point<T>> for &Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: &mut Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<T> for &mut Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: T) -> Self::Output {
        Point::from((self.x%rhs, self.y%rhs))
    }
}

impl<T: Integer + Copy> Rem<(T, T)> for &mut Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: (T, T)) -> Self::Output {
        Point::from((self.x%rhs.0, self.y%rhs.1))
    }
}

impl<T: Integer + Copy> Rem<Point<T>> for &mut Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&Point<T>> for &mut Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: &Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}

impl<T: Integer + Copy> Rem<&mut Point<T>> for &mut Point<T> {
    type Output = Point<T>;
    fn rem(self, rhs: &mut Point<T>) -> Self::Output {
        Point::from((self.x%rhs.x, self.y%rhs.y))
    }
}


impl<T: Integer + RemAssign + Copy> RemAssign<T> for Point<T> {
    fn rem_assign(&mut self, rhs: T) {
        self.x %= rhs;
        self.y %= rhs;
    }
}

impl<T: Integer + RemAssign> RemAssign<(T, T)> for Point<T> {
    fn rem_assign(&mut self, rhs: (T, T)) {
        self.x %= rhs.0;
        self.y %= rhs.1;
    }
}

impl<T: Integer + RemAssign + Copy> RemAssign<Point<T>> for Point<T> {
    fn rem_assign(&mut self, rhs: Point<T>) {
        self.x %= rhs.x;
        self.y %= rhs.y;
    }
}

impl<T: Integer + RemAssign + Copy> RemAssign<&Point<T>> for Point<T> {
    fn rem_assign(&mut self, rhs: &Point<T>) {
        self.x %= rhs.x;
        self.y %= rhs.y;
    }
}

impl<T: Integer + RemAssign + Copy> RemAssign<&mut Point<T>> for Point<T> {
    fn rem_assign(&mut self, rhs: &mut Point<T>) {
        self.x %= rhs.x;
        self.y %= rhs.y;
    }
}