mathhook_core/core/expression/
operators.rs

1//! Operator overloading for expressions to enable natural mathematical syntax
2
3use crate::core::Expression;
4use std::ops::{Add, Mul, Neg, Sub};
5
6// Addition operators
7impl Add for Expression {
8    type Output = Expression;
9
10    fn add(self, rhs: Expression) -> Expression {
11        Expression::add(vec![self, rhs])
12    }
13}
14
15impl Add for &Expression {
16    type Output = Expression;
17
18    fn add(self, rhs: &Expression) -> Expression {
19        Expression::add(vec![self.clone(), rhs.clone()])
20    }
21}
22
23impl Add<&Expression> for Expression {
24    type Output = Expression;
25
26    fn add(self, rhs: &Expression) -> Expression {
27        Expression::add(vec![self, rhs.clone()])
28    }
29}
30
31impl Add<Expression> for &Expression {
32    type Output = Expression;
33
34    fn add(self, rhs: Expression) -> Expression {
35        Expression::add(vec![self.clone(), rhs])
36    }
37}
38
39// Integer addition
40impl Add<i32> for Expression {
41    type Output = Expression;
42
43    fn add(self, rhs: i32) -> Expression {
44        Expression::add(vec![self, Expression::integer(rhs as i64)])
45    }
46}
47
48impl Add<Expression> for i32 {
49    type Output = Expression;
50
51    fn add(self, rhs: Expression) -> Expression {
52        Expression::add(vec![Expression::integer(self as i64), rhs])
53    }
54}
55
56impl Add<i32> for &Expression {
57    type Output = Expression;
58
59    fn add(self, rhs: i32) -> Expression {
60        Expression::add(vec![self.clone(), Expression::integer(rhs as i64)])
61    }
62}
63
64impl Add<&Expression> for i32 {
65    type Output = Expression;
66
67    fn add(self, rhs: &Expression) -> Expression {
68        Expression::add(vec![Expression::integer(self as i64), rhs.clone()])
69    }
70}
71
72// Subtraction operators
73impl Sub for Expression {
74    type Output = Expression;
75
76    fn sub(self, rhs: Expression) -> Expression {
77        Expression::add(vec![self, -rhs])
78    }
79}
80
81impl Sub for &Expression {
82    type Output = Expression;
83
84    fn sub(self, rhs: &Expression) -> Expression {
85        Expression::add(vec![self.clone(), -rhs.clone()])
86    }
87}
88
89impl Sub<&Expression> for Expression {
90    type Output = Expression;
91
92    fn sub(self, rhs: &Expression) -> Expression {
93        Expression::add(vec![self, -rhs.clone()])
94    }
95}
96
97impl Sub<Expression> for &Expression {
98    type Output = Expression;
99
100    fn sub(self, rhs: Expression) -> Expression {
101        Expression::add(vec![self.clone(), -rhs])
102    }
103}
104
105// Integer subtraction
106impl Sub<i32> for Expression {
107    type Output = Expression;
108
109    fn sub(self, rhs: i32) -> Expression {
110        Expression::add(vec![self, Expression::integer(-rhs as i64)])
111    }
112}
113
114impl Sub<Expression> for i32 {
115    type Output = Expression;
116
117    fn sub(self, rhs: Expression) -> Expression {
118        Expression::add(vec![Expression::integer(self as i64), -rhs])
119    }
120}
121
122// Multiplication operators
123impl Mul for Expression {
124    type Output = Expression;
125
126    fn mul(self, rhs: Expression) -> Expression {
127        Expression::mul(vec![self, rhs])
128    }
129}
130
131impl Mul for &Expression {
132    type Output = Expression;
133
134    fn mul(self, rhs: &Expression) -> Expression {
135        Expression::mul(vec![self.clone(), rhs.clone()])
136    }
137}
138
139impl Mul<&Expression> for Expression {
140    type Output = Expression;
141
142    fn mul(self, rhs: &Expression) -> Expression {
143        Expression::mul(vec![self, rhs.clone()])
144    }
145}
146
147impl Mul<Expression> for &Expression {
148    type Output = Expression;
149
150    fn mul(self, rhs: Expression) -> Expression {
151        Expression::mul(vec![self.clone(), rhs])
152    }
153}
154
155// Integer multiplication
156impl Mul<i32> for Expression {
157    type Output = Expression;
158
159    fn mul(self, rhs: i32) -> Expression {
160        Expression::mul(vec![self, Expression::integer(rhs as i64)])
161    }
162}
163
164impl Mul<Expression> for i32 {
165    type Output = Expression;
166
167    fn mul(self, rhs: Expression) -> Expression {
168        Expression::mul(vec![Expression::integer(self as i64), rhs])
169    }
170}
171
172impl Mul<i32> for &Expression {
173    type Output = Expression;
174
175    fn mul(self, rhs: i32) -> Expression {
176        Expression::mul(vec![self.clone(), Expression::integer(rhs as i64)])
177    }
178}
179
180impl Mul<&Expression> for i32 {
181    type Output = Expression;
182
183    fn mul(self, rhs: &Expression) -> Expression {
184        Expression::mul(vec![Expression::integer(self as i64), rhs.clone()])
185    }
186}
187
188// Negation operator
189impl Neg for Expression {
190    type Output = Expression;
191
192    fn neg(self) -> Expression {
193        Expression::mul(vec![Expression::integer(-1), self])
194    }
195}
196
197impl Neg for &Expression {
198    type Output = Expression;
199
200    fn neg(self) -> Expression {
201        Expression::mul(vec![Expression::integer(-1), self.clone()])
202    }
203}
204
205#[cfg(test)]
206mod tests {
207    use crate::{expr, Expression};
208
209    #[test]
210    fn test_addition() {
211        let x = expr!(x);
212        let y = expr!(y);
213        let sum = &x + &y;
214
215        assert!(matches!(sum, Expression::Add(_)));
216    }
217
218    #[test]
219    fn test_multiplication() {
220        let x = expr!(x);
221        let two = Expression::integer(2);
222        let product = &x * &two;
223
224        assert!(matches!(product, Expression::Mul(_)));
225    }
226
227    #[test]
228    fn test_integer_ops() {
229        let x = expr!(x);
230        let sum = &x + 5;
231        let product = 3 * &x;
232
233        assert!(matches!(sum, Expression::Add(_)));
234        assert!(matches!(product, Expression::Mul(_)));
235    }
236
237    #[test]
238    fn test_negation() {
239        let x = expr!(x);
240        let neg_x = -&x;
241
242        assert!(matches!(neg_x, Expression::Mul(_)));
243    }
244}
mathhook_core/core/expression/operators.rs

mathhook_core/core/expression/
operators.rs
