electrical_mesurements/units/
hertz.rs

1use std::fmt;
2use std::ops::{Mul, MulAssign, Div, DivAssign, Add, AddAssign, Sub, SubAssign, Rem, RemAssign};
3
4
5#[derive(PartialEq, Debug, Copy, Clone)]
6pub struct Hertz {
7    pub(crate) value: f64,
8}
9
10impl Hertz {
11    pub fn new(value: f64) -> Self {
12        Self { value }
13    }
14
15    pub fn new_kilohertz(value: f64) -> Self {
16        Self { value: value * 1e3 }
17    }
18
19    pub fn new_megahertz(value: f64) -> Self {
20        Self { value: value * 1e6 }
21    }
22
23    pub fn new_gigahertz(value: f64) -> Self {
24        Self { value: value * 1e9 }
25    }
26
27    pub fn reciprocal(&self) -> Self {
28        Self { value: 1.0 / self.value }
29    }
30}
31
32impl Mul<Hertz> for Hertz {
33    type Output = Hertz;
34
35    fn mul(self, other: Hertz) -> Hertz {
36        Hertz::new(self.value * other.value)
37    }
38}
39
40impl Mul<Hertz> for f64 {
41    type Output = Hertz;
42
43    fn mul(self, other: Hertz) -> Hertz {
44        Hertz::new(self * other.value)
45    }
46}
47
48impl MulAssign<Hertz> for Hertz {
49    fn mul_assign(&mut self, other: Hertz) {
50        *self = Hertz::new(self.value * other.value);
51    }
52}
53
54impl Div<Hertz> for Hertz {
55    type Output = Hertz;
56
57    fn div(self, other: Hertz) -> Hertz {
58        Hertz::new(self.value / other.value)
59    }
60}
61
62impl DivAssign<Hertz> for Hertz {
63    fn div_assign(&mut self, other: Hertz) {
64        *self = Hertz::new(self.value / other.value);
65    }
66}
67
68impl Add<Hertz> for Hertz {
69    type Output = Hertz;
70
71    fn add(self, other: Hertz) -> Hertz {
72        Hertz::new(self.value + other.value)
73    }
74}
75
76impl AddAssign<Hertz> for Hertz {
77    fn add_assign(&mut self, other: Hertz) {
78        *self = Hertz::new(self.value + other.value);
79    }
80}
81
82impl Sub<Hertz> for Hertz {
83    type Output = Hertz;
84
85    fn sub(self, other: Hertz) -> Hertz {
86        Hertz::new(self.value - other.value)
87    }
88}
89
90impl SubAssign<Hertz> for Hertz {
91    fn sub_assign(&mut self, other: Hertz) {
92        *self = Hertz::new(self.value - other.value);
93    }
94}
95
96impl Rem<Hertz> for Hertz {
97    type Output = Hertz;
98
99    fn rem(self, other: Hertz) -> Hertz {
100        Hertz::new(self.value % other.value)
101    }
102}
103
104impl RemAssign<Hertz> for Hertz {
105    fn rem_assign(&mut self, other: Hertz) {
106        *self = Hertz::new(self.value % other.value);
107    }
108}
109
110impl fmt::Display for Hertz {
111    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
112        write!(f, "{:.} Hz", self.value)
113    }
114}
115
116#[cfg(test)]
117mod tests {
118
119    use super::*;
120
121    #[test]
122    fn hertz_eq_hertz() {
123        let a = Hertz::new(1.0);
124        let b = Hertz::new(1.0);
125        assert_eq!(a, b);
126    }
127
128    #[test]
129    fn one_thousand_hertz_eq_kilohertz() {
130        let a = Hertz::new(1_000.0);
131        let b = Hertz::new_kilohertz(1.0);
132        assert_eq!(a, b);
133    }
134
135    #[test]
136    fn one_million_hertz_eq_megahertz() {
137        let a = Hertz::new(1_000_000.0);
138        let b = Hertz::new_megahertz(1.0);
139        assert_eq!(a, b);
140    }
141
142    #[test]
143    fn one_billion_hertz_eq_gigahertz() {
144        let a = Hertz::new(1_000_000_000.0);
145        let b = Hertz::new_gigahertz(1.0);
146        assert_eq!(a, b);
147    }
148
149    #[test]
150    fn hertz_mul_hertz() {
151        let a = Hertz::new(1.0);
152        let b = Hertz::new(2.0);
153        let c = Hertz::new(2.0);
154        assert_eq!(a * b, c);
155    }
156
157    #[test]
158    fn hertz_mul_assign_hertz() {
159        let mut a = Hertz::new(1.0);
160        let b = Hertz::new(2.0);
161        let c = Hertz::new(2.0);
162        a *= b;
163        assert_eq!(a, c);
164    }
165
166    #[test]
167    fn hertz_div_hertz() {
168        let a = Hertz::new(2.0);
169        let b = Hertz::new(2.0);
170        let c = Hertz::new(1.0);
171        assert_eq!(a / b, c);
172    }
173
174    #[test]
175    fn hertz_div_assign_hertz() {
176        let mut a = Hertz::new(2.0);
177        let b = Hertz::new(2.0);
178        let c = Hertz::new(1.0);
179        a /= b;
180        assert_eq!(a, c);
181    }
182
183    #[test]
184    fn hertz_add_hertz() {
185        let a = Hertz::new(1.0);
186        let b = Hertz::new(2.0);
187        let c = Hertz::new(3.0);
188        assert_eq!(a + b, c);
189    }
190
191    #[test]
192    fn hertz_add_assign_hertz() {
193        let mut a = Hertz::new(1.0);
194        let b = Hertz::new(2.0);
195        let c = Hertz::new(3.0);
196        a += b;
197        assert_eq!(a, c);
198    }
199
200    #[test]
201    fn hertz_sub_hertz() {
202        let a = Hertz::new(3.0);
203        let b = Hertz::new(2.0);
204        let c = Hertz::new(1.0);
205        assert_eq!(a - b, c);
206    }
207
208    #[test]
209    fn hertz_sub_assign_hertz() {
210        let mut a = Hertz::new(3.0);
211        let b = Hertz::new(2.0);
212        let c = Hertz::new(1.0);
213        a -= b;
214        assert_eq!(a, c);
215    }
216
217    #[test]
218    fn hertz_rem_hertz() {
219        let a = Hertz::new(3.0);
220        let b = Hertz::new(2.0);
221        let c = Hertz::new(1.0);
222        assert_eq!(a % b, c);
223    }
224
225    #[test]
226    fn hertz_rem_assign_hertz() {
227        let mut a = Hertz::new(3.0);
228        let b = Hertz::new(2.0);
229        let c = Hertz::new(1.0);
230        a %= b;
231        assert_eq!(a, c);
232    }
233
234    #[test]
235    fn hertz_display() {
236        let a = Hertz::new(1.0);
237        assert_eq!(format!("{}", a), "1 Hz");
238    }
239
240}
electrical_mesurements/units/hertz.rs

electrical_mesurements/units/
hertz.rs
