1use std::ops::Mul;
2
3use crate::{base, derived};
4
5impl<Number> base::BaseValue<Number> {
6 pub const fn kilograms(number: Number) -> Self {
7 Self {
8 unit: base::KILOGRAM,
9 number,
10 }
11 }
12
13 pub const fn meters(number: Number) -> Self {
14 Self {
15 unit: base::METER,
16 number,
17 }
18 }
19
20 pub const fn seconds(number: Number) -> Self {
21 Self {
22 unit: base::SECOND,
23 number,
24 }
25 }
26
27 pub const fn moles(number: Number) -> Self {
28 Self {
29 unit: base::MOLE,
30 number,
31 }
32 }
33
34 pub const fn amperes(number: Number) -> Self {
35 Self {
36 unit: base::AMPERE,
37 number,
38 }
39 }
40
41 pub const fn kelvin(number: Number) -> Self {
42 Self {
43 unit: base::KELVIN,
44 number,
45 }
46 }
47
48 pub const fn candela(number: Number) -> Self {
49 Self {
50 unit: base::CANDELA,
51 number,
52 }
53 }
54}
55
56impl<Number> base::BaseValue<Number> {
57 pub const fn hertz(number: Number) -> Self {
58 Self {
59 unit: base::HERTZ,
60 number,
61 }
62 }
63
64 pub const fn newton(number: Number) -> Self {
65 Self {
66 unit: base::NEWTON,
67 number,
68 }
69 }
70
71 pub const fn pascal(number: Number) -> Self {
72 Self {
73 unit: base::PASCAL,
74 number,
75 }
76 }
77
78 pub const fn joules(number: Number) -> Self {
79 Self {
80 unit: base::JOULE,
81 number,
82 }
83 }
84
85 pub const fn coulombs(number: Number) -> Self {
86 Self {
87 unit: base::COULOMB,
88 number,
89 }
90 }
91
92 pub const fn volts(number: Number) -> Self {
93 Self {
94 unit: base::VOLT,
95 number,
96 }
97 }
98
99 pub const fn farads(number: Number) -> Self {
100 Self {
101 unit: base::FARAD,
102 number,
103 }
104 }
105
106 pub const fn ohms(number: Number) -> Self {
107 Self {
108 unit: base::OHM,
109 number,
110 }
111 }
112
113 pub const fn siemens(number: Number) -> Self {
114 Self {
115 unit: base::SIEMENS,
116 number,
117 }
118 }
119
120 pub const fn webers(number: Number) -> Self {
121 Self {
122 unit: base::WEBER,
123 number,
124 }
125 }
126
127 pub const fn teslas(number: Number) -> Self {
128 Self {
129 unit: base::TESLA,
130 number,
131 }
132 }
133
134 pub const fn henries(number: Number) -> Self {
135 Self {
136 unit: base::HENRY,
137 number,
138 }
139 }
140
141 pub const fn lux(number: Number) -> Self {
142 Self {
143 unit: base::LUX,
144 number,
145 }
146 }
147
148 pub const fn becquerels(number: Number) -> Self {
149 Self {
150 unit: base::BECQUEREL,
151 number,
152 }
153 }
154
155 pub const fn grays(number: Number) -> Self {
156 Self {
157 unit: base::GRAY,
158 number,
159 }
160 }
161
162 pub const fn sieverts(number: Number) -> Self {
163 Self {
164 unit: base::SIEVERT,
165 number,
166 }
167 }
168
169 pub const fn katals(number: Number) -> Self {
170 Self {
171 unit: base::KATAL,
172 number,
173 }
174 }
175}
176
177impl<Number> derived::DerivedValue<Number> {
178 pub const fn kilograms(number: Number) -> Self {
179 Self {
180 unit: derived::KILOGRAM,
181 number,
182 }
183 }
184
185 pub const fn meters(number: Number) -> Self {
186 Self {
187 unit: derived::METER,
188 number,
189 }
190 }
191
192 pub const fn seconds(number: Number) -> Self {
193 Self {
194 unit: derived::SECOND,
195 number,
196 }
197 }
198
199 pub const fn moles(number: Number) -> Self {
200 Self {
201 unit: derived::MOLE,
202 number,
203 }
204 }
205
206 pub const fn amperes(number: Number) -> Self {
207 Self {
208 unit: derived::AMPERE,
209 number,
210 }
211 }
212
213 pub const fn kelvin(number: Number) -> Self {
214 Self {
215 unit: derived::KELVIN,
216 number,
217 }
218 }
219
220 pub const fn candela(number: Number) -> Self {
221 Self {
222 unit: derived::CANDELA,
223 number,
224 }
225 }
226}
227
228impl<Number> derived::DerivedValue<Number> {
229 pub const fn hertz(number: Number) -> Self {
230 Self {
231 unit: derived::HERTZ,
232 number,
233 }
234 }
235
236 pub const fn newton(number: Number) -> Self {
237 Self {
238 unit: derived::NEWTON,
239 number,
240 }
241 }
242
243 pub const fn pascal(number: Number) -> Self {
244 Self {
245 unit: derived::PASCAL,
246 number,
247 }
248 }
249
250 pub const fn joules(number: Number) -> Self {
251 Self {
252 unit: derived::JOULE,
253 number,
254 }
255 }
256
257 pub const fn coulombs(number: Number) -> Self {
258 Self {
259 unit: derived::COULOMB,
260 number,
261 }
262 }
263
264 pub const fn volts(number: Number) -> Self {
265 Self {
266 unit: derived::VOLT,
267 number,
268 }
269 }
270
271 pub const fn farads(number: Number) -> Self {
272 Self {
273 unit: derived::FARAD,
274 number,
275 }
276 }
277
278 pub const fn ohms(number: Number) -> Self {
279 Self {
280 unit: derived::OHM,
281 number,
282 }
283 }
284
285 pub const fn siemens(number: Number) -> Self {
286 Self {
287 unit: derived::SIEMENS,
288 number,
289 }
290 }
291
292 pub const fn webers(number: Number) -> Self {
293 Self {
294 unit: derived::WEBER,
295 number,
296 }
297 }
298
299 pub const fn teslas(number: Number) -> Self {
300 Self {
301 unit: derived::TESLA,
302 number,
303 }
304 }
305
306 pub const fn henries(number: Number) -> Self {
307 Self {
308 unit: derived::HENRY,
309 number,
310 }
311 }
312
313 pub const fn lux(number: Number) -> Self {
314 Self {
315 unit: derived::LUX,
316 number,
317 }
318 }
319
320 pub const fn becquerels(number: Number) -> Self {
321 Self {
322 unit: derived::BECQUEREL,
323 number,
324 }
325 }
326
327 pub const fn grays(number: Number) -> Self {
328 Self {
329 unit: derived::GRAY,
330 number,
331 }
332 }
333
334 pub const fn sieverts(number: Number) -> Self {
335 Self {
336 unit: derived::SIEVERT,
337 number,
338 }
339 }
340
341 pub const fn katals(number: Number) -> Self {
342 Self {
343 unit: derived::KATAL,
344 number,
345 }
346 }
347}
348
349
350impl<Number> base::BaseValue<Number>
351where
352 Number: Mul<Output = Number>,
353 Number: From<u16>
354{
355 pub fn minutes(number: Number) -> Self {
356 Self {
357 unit: base::SECOND,
358 number: number * (60u16.into()),
359 }
360 }
361
362 pub fn hours(number: Number) -> Self {
363 Self {
364 unit: base::SECOND,
365 number: number * (3600u16.into()),
366 }
367 }
368}
369
370
371impl<Number> derived::DerivedValue<Number>
372where
373 Number: Mul<Output = Number>,
374 Number: From<u16>
375{
376 pub fn minutes(number: Number) -> Self {
377 Self {
378 unit: derived::SECOND,
379 number: number * (60u16.into()),
380 }
381 }
382
383 pub fn hours(number: Number) -> Self {
384 Self {
385 unit: derived::SECOND,
386 number: number * (3600u16.into()),
387 }
388 }
389}
390
391#[cfg(test)]
392mod tests {
393 use crate::{base, derived};
394
395 #[test]
396 fn test_time_base_int() {
397 assert_eq!(base::BaseValue::seconds(60), base::BaseValue::minutes(1));
398 assert_eq!(base::BaseValue::seconds(120), base::BaseValue::minutes(2));
399 assert_eq!(base::BaseValue::seconds(180), base::BaseValue::minutes(3));
400 assert_eq!(base::BaseValue::seconds(240), base::BaseValue::minutes(4));
401 assert_eq!(base::BaseValue::seconds(300), base::BaseValue::minutes(5));
402 assert_eq!(base::BaseValue::seconds(360), base::BaseValue::minutes(6));
403 }
404
405 #[test]
406 fn test_time_derived_int() {
407 assert_eq!(derived::DerivedValue::seconds(60), derived::DerivedValue::minutes(1));
408 assert_eq!(derived::DerivedValue::seconds(120), derived::DerivedValue::minutes(2));
409 assert_eq!(derived::DerivedValue::seconds(180), derived::DerivedValue::minutes(3));
410 assert_eq!(derived::DerivedValue::seconds(240), derived::DerivedValue::minutes(4));
411 assert_eq!(derived::DerivedValue::seconds(300), derived::DerivedValue::minutes(5));
412 assert_eq!(derived::DerivedValue::seconds(360), derived::DerivedValue::minutes(6));
413 }
414
415 #[test]
416 fn test_time_base_float() {
417 assert_eq!(base::BaseValue::seconds(0f32), base::BaseValue::minutes(0f32));
419 assert_eq!(base::BaseValue::seconds(15f32), base::BaseValue::minutes(0.25f32));
420 assert_eq!(base::BaseValue::seconds(30f32), base::BaseValue::minutes(0.5f32));
421 assert_eq!(base::BaseValue::seconds(45f32), base::BaseValue::minutes(0.75f32));
422 assert_eq!(base::BaseValue::seconds(60f32), base::BaseValue::minutes(1f32));
423 assert_eq!(base::BaseValue::seconds(75f32), base::BaseValue::minutes(1.25f32));
424 assert_eq!(base::BaseValue::seconds(90f32), base::BaseValue::minutes(1.5f32));
425
426 assert_eq!(base::BaseValue::seconds(0f32), base::BaseValue::hours(0f32));
427 assert_eq!(base::BaseValue::seconds(900f32), base::BaseValue::hours(0.25f32));
428 assert_eq!(base::BaseValue::seconds(1800f32), base::BaseValue::hours(0.5f32));
429 assert_eq!(base::BaseValue::seconds(2700f32), base::BaseValue::hours(0.75f32));
430 assert_eq!(base::BaseValue::seconds(3600f32), base::BaseValue::hours(1f32));
431 assert_eq!(base::BaseValue::seconds(4500f32), base::BaseValue::hours(1.25f32));
432 assert_eq!(base::BaseValue::seconds(5400f32), base::BaseValue::hours(1.5f32));
433 }
434
435 #[test]
436 fn test_time_derived_float() {
437 assert_eq!(derived::DerivedValue::seconds(0f32), derived::DerivedValue::minutes(0f32));
439 assert_eq!(derived::DerivedValue::seconds(15f32), derived::DerivedValue::minutes(0.25f32));
440 assert_eq!(derived::DerivedValue::seconds(30f32), derived::DerivedValue::minutes(0.5f32));
441 assert_eq!(derived::DerivedValue::seconds(45f32), derived::DerivedValue::minutes(0.75f32));
442 assert_eq!(derived::DerivedValue::seconds(60f32), derived::DerivedValue::minutes(1f32));
443 assert_eq!(derived::DerivedValue::seconds(75f32), derived::DerivedValue::minutes(1.25f32));
444 assert_eq!(derived::DerivedValue::seconds(90f32), derived::DerivedValue::minutes(1.5f32));
445
446 assert_eq!(derived::DerivedValue::seconds(0f32), derived::DerivedValue::hours(0f32));
447 assert_eq!(derived::DerivedValue::seconds(900f32), derived::DerivedValue::hours(0.25f32));
448 assert_eq!(derived::DerivedValue::seconds(1800f32), derived::DerivedValue::hours(0.5f32));
449 assert_eq!(derived::DerivedValue::seconds(2700f32), derived::DerivedValue::hours(0.75f32));
450 assert_eq!(derived::DerivedValue::seconds(3600f32), derived::DerivedValue::hours(1f32));
451 assert_eq!(derived::DerivedValue::seconds(4500f32), derived::DerivedValue::hours(1.25f32));
452 assert_eq!(derived::DerivedValue::seconds(5400f32), derived::DerivedValue::hours(1.5f32));
453 }
454}