1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use std::ops::{Div, DivAssign, Mul, MulAssign};

use simba::scalar::{ClosedAddAssign, ClosedSubAssign};

use crate::base::constraint::{SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
use crate::base::dimension::U1;
use crate::base::{Const, Scalar};

use crate::geometry::{Point, Translation};

// Translation × Translation
add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + &right.vector) };
    'a, 'b);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector + right.vector) };
    'a);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + &right.vector) };
    'b);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector + right.vector) }; );

// Translation ÷ Translation
// TODO: instead of calling inverse explicitly, could we just add a `mul_tr` or `mul_inv` method?
add_sub_impl!(Div, div, ClosedSubAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - &right.vector) };
    'a, 'b);

add_sub_impl!(Div, div, ClosedSubAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(&self.vector - right.vector) };
    'a);

add_sub_impl!(Div, div, ClosedSubAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: &'b Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - &right.vector) };
    'b);

add_sub_impl!(Div, div, ClosedSubAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: Translation<T, D>, Output = Translation<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { Translation::from(self.vector - right.vector) }; );

// Translation × Point
// TODO: we don't handle properly non-zero origins here. Do we want this to be the intended
// behavior?
add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
    'a, 'b);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: &'a Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { right + &self.vector };
    'a);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: &'b Point<T, D>, Output = Point<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector };
    'b);

add_sub_impl!(Mul, mul, ClosedAddAssign;
    (Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1)
    const D; for; where;
    self: Translation<T, D>, right: Point<T, D>, Output = Point<T, D>;
    #[allow(clippy::suspicious_arithmetic_impl)] { right + self.vector }; );

// Translation *= Translation
add_sub_assign_impl!(MulAssign, mul_assign, ClosedAddAssign;
    const D;
    self: Translation<T, D>, right: &'b Translation<T, D>;
    #[allow(clippy::suspicious_op_assign_impl)] { self.vector += &right.vector };
    'b);

add_sub_assign_impl!(MulAssign, mul_assign, ClosedAddAssign;
    const D;
    self: Translation<T, D>, right: Translation<T, D>;
    #[allow(clippy::suspicious_op_assign_impl)] { self.vector += right.vector }; );

add_sub_assign_impl!(DivAssign, div_assign, ClosedSubAssign;
    const D;
    self: Translation<T, D>, right: &'b Translation<T, D>;
    #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= &right.vector };
    'b);

add_sub_assign_impl!(DivAssign, div_assign, ClosedSubAssign;
    const D;
    self: Translation<T, D>, right: Translation<T, D>;
    #[allow(clippy::suspicious_op_assign_impl)] { self.vector -= right.vector }; );