tawasuyu/taffy

1use std::ops;
2
3#[derive(Copy, Clone, PartialEq, Debug)]
4pub enum Number {
5    Defined(f32),
6    Undefined,
7}
8
9impl Default for Number {
10    fn default() -> Number {
11        Number::Undefined
12    }
13}
14
15impl Number {
16    pub fn unwrap_or(self, default: f32) -> f32 {
17        match self {
18            Number::Defined(val) => val,
19            Number::Undefined => default,
20        }
21    }
22
23    pub fn is_defined(self) -> bool {
24        match self {
25            Number::Defined(_) => true,
26            Number::Undefined => false,
27        }
28    }
29
30    pub fn is_undefined(self) -> bool {
31        match self {
32            Number::Defined(_) => false,
33            Number::Undefined => true,
34        }
35    }
36
37    pub fn from_f32(from: f32) -> Number {
38        if from.is_nan() {
39            Number::Undefined
40        } else {
41            Number::Defined(from)
42        }
43    }
44}
45
46pub trait MinMax<T> {
47    fn maybe_min(self, rhs: T) -> Number;
48    fn maybe_max(self, rhs: T) -> Number;
49}
50
51impl MinMax<Number> for Number {
52    fn maybe_min(self, rhs: Number) -> Number {
53        match self {
54            Number::Defined(val) => match rhs {
55                Number::Defined(other) => Number::Defined(val.min(other)),
56                Number::Undefined => self,
57            },
58            Number::Undefined => Number::Undefined,
59        }
60    }
61
62    fn maybe_max(self, rhs: Number) -> Number {
63        match self {
64            Number::Defined(val) => match rhs {
65                Number::Defined(other) => Number::Defined(val.max(other)),
66                Number::Undefined => self,
67            },
68            Number::Undefined => Number::Undefined,
69        }
70    }
71}
72
73impl MinMax<f32> for Number {
74    fn maybe_min(self, rhs: f32) -> Number {
75        match self {
76            Number::Defined(val) => Number::Defined(val.min(rhs)),
77            Number::Undefined => Number::Undefined,
78        }
79    }
80
81    fn maybe_max(self, rhs: f32) -> Number {
82        match self {
83            Number::Defined(val) => Number::Defined(val.max(rhs)),
84            Number::Undefined => Number::Undefined,
85        }
86    }
87}
88
89impl MinMax<Number> for f32 {
90    fn maybe_min(self, rhs: Number) -> Number {
91        match rhs {
92            Number::Defined(val) => Number::Defined(self.min(val)),
93            Number::Undefined => Number::Defined(self),
94        }
95    }
96
97    fn maybe_max(self, rhs: Number) -> Number {
98        match rhs {
99            Number::Defined(val) => Number::Defined(self.max(val)),
100            Number::Undefined => Number::Defined(self),
101        }
102    }
103}
104
105impl ops::Add<f32> for Number {
106    type Output = Number;
107
108    fn add(self, rhs: f32) -> Number {
109        match self {
110            Number::Defined(val) => Number::Defined(val + rhs),
111            Number::Undefined => Number::Undefined,
112        }
113    }
114}
115
116impl ops::Add<Number> for Number {
117    type Output = Number;
118
119    fn add(self, rhs: Number) -> Number {
120        match self {
121            Number::Defined(val) => match rhs {
122                Number::Defined(other) => Number::Defined(val + other),
123                Number::Undefined => self,
124            },
125            Number::Undefined => Number::Undefined,
126        }
127    }
128}
129
130impl ops::Sub<f32> for Number {
131    type Output = Number;
132
133    fn sub(self, rhs: f32) -> Number {
134        match self {
135            Number::Defined(val) => Number::Defined(val - rhs),
136            Number::Undefined => Number::Undefined,
137        }
138    }
139}
140
141impl ops::Sub<Number> for Number {
142    type Output = Number;
143
144    fn sub(self, rhs: Number) -> Number {
145        match self {
146            Number::Defined(val) => match rhs {
147                Number::Defined(other) => Number::Defined(val - other),
148                Number::Undefined => self,
149            },
150            Number::Undefined => Number::Undefined,
151        }
152    }
153}
154
155impl ops::Mul<f32> for Number {
156    type Output = Number;
157
158    fn mul(self, rhs: f32) -> Number {
159        match self {
160            Number::Defined(val) => Number::Defined(val * rhs),
161            Number::Undefined => Number::Undefined,
162        }
163    }
164}
165
166impl ops::Mul<Number> for Number {
167    type Output = Number;
168
169    fn mul(self, rhs: Number) -> Number {
170        match self {
171            Number::Defined(val) => match rhs {
172                Number::Defined(other) => Number::Defined(val * other),
173                Number::Undefined => self,
174            },
175            Number::Undefined => Number::Undefined,
176        }
177    }
178}
179
180impl ops::Div<f32> for Number {
181    type Output = Number;
182
183    fn div(self, rhs: f32) -> Number {
184        match self {
185            Number::Defined(val) => Number::Defined(val / rhs),
186            Number::Undefined => Number::Undefined,
187        }
188    }
189}
190
191impl ops::Div<Number> for Number {
192    type Output = Number;
193
194    fn div(self, rhs: Number) -> Number {
195        match self {
196            Number::Defined(val) => match rhs {
197                Number::Defined(other) => Number::Defined(val / other),
198                Number::Undefined => self,
199            },
200            Number::Undefined => Number::Undefined,
201        }
202    }
203}