Impl Div for Vector, Add, Mul, Div for Size, etc

[ArtHome12]

I found that the mathematical operations on Size, Point, Vector are only partially implemented and prepared changes to support +, -, *, /, %, as well as +=, -=, *=, /=, %=. The second operand can be either a scalar or Self.

If there are no comments, I will send a request. Now I'm still testing the changes on a real project.

Below is sample code and tests

#[test]
fn test_add() {
    let mut a = Size::UNIT;
    let other = Size::new(10.0, 20.0);
    let r = Size::new(11.0, 21.0);
    assert_eq!(r, a + other, "a + other self");
    a += other;
    assert_eq!(r, a, "a += other self");
    
    a = Size::new(8.0, 18.0);
    let other = 3.0_f32;
    assert_eq!(r, a + other, "a + other scalar");
    a += other;
    assert_eq!(r, a, "a += other scalar");
}

// Addition with own type
impl<T> std::ops::Add for Size<T>
where
    T: std::ops::Add<Output = T> + Copy,
{
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
        Size {
            width: self.width + other.width,
            height: self.height + other.height,
        }
    }
}

impl<T> std::ops::AddAssign for Size<T>
where
    T: std::ops::AddAssign + Copy,
{
    fn add_assign(&mut self, other: Self) {
        self.width += other.width;
        self.height += other.height;
    }
}

// Addition with scalar
impl<T> std::ops::Add<T> for Size<T>
where
    T: std::ops::Add<Output = T> + Copy,
{
    type Output = Self;

    fn add(self, other: T) -> Self::Output {
        Size {
            width: self.width + other,
            height: self.height + other,
        }
    }
}

impl<T> std::ops::AddAssign<T> for Size<T>
where
    T: std::ops::AddAssign + Copy,
{
    fn add_assign(&mut self, other: T) {
        self.width += other;
        self.height += other;
    }
}

[Mingun]

Perhaps it is worth considering the use of a geometric library, for example, euclid.

[ArtHome12]

Perhaps, but it won't replace the lack of elementary arithmetic operations, forcing to write something like
let c = Vector::new(a.x % b.x, a.y % b.y); instead let c = a % b;

[Mingun]

Yes, Rem currently is not implemented for euclid vectors, but this can be easely changed by submitting a PR. Of course, right now it could be more practical to implement necessary operators for existing types, but why do a double work when someone already did it?

The ability to tag things could be especially useful in layout engines, which generally operates on coordinates in parent and child frame of reference.

[ArtHome12]

Yes. I'm starting to lean towards leaving only From and Into in Size, Vector and Point to some kind of geometric library, like euclid. Because after the implementation of elementary arithmetic operations, it will wants more and hello, bicycle

[ArtHome12]

Point is tied to type f32 due to f32.hypot(). Therefore, I propose to add arithmetic only for Size and Vector, into which to convert Point if necessary.

[ArtHome12]

#1725