unitforge 0.4.3

A library for unit and quantity consistent computations in Rust
Documentation 
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

use crate::impl_macros::macros::*;
use crate::quantities::*;

#[cfg_attr(feature = "strum", derive(EnumIter))]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[derive(Copy, Clone, PartialEq, Debug, Hash, Eq)]
#[cfg_attr(feature = "pyo3", pyclass(eq, eq_int, from_py_object))]
pub enum FrequencyUnit {
    Hz,
    kHz,
    MHz,
    GHz,
    rpm,
}

impl FrequencyUnit {
    pub const fn base_per_x_const(self) -> (f64, i32) {
        match self {
            FrequencyUnit::Hz => (1., 0),
            FrequencyUnit::kHz => (1., 3),
            FrequencyUnit::MHz => (1., 6),
            FrequencyUnit::GHz => (1., 9),
            FrequencyUnit::rpm => (1. / 60., 0),
        }
    }
}

impl PhysicsUnit for FrequencyUnit {
    fn name(&self) -> &str {
        match &self {
            FrequencyUnit::Hz => "Hz",
            FrequencyUnit::kHz => "kHz",
            FrequencyUnit::MHz => "MHz",
            FrequencyUnit::GHz => "GHz",
            FrequencyUnit::rpm => "rpm",
        }
    }

    fn base_per_x(&self) -> (f64, i32) {
        (*self).base_per_x_const()
    }
}

impl_quantity!(Frequency, FrequencyUnit, [FrequencyUnit::Hz]);
impl_div_with_self_to_f64!(Frequency);

impl Div<Time> for f64 {
    type Output = Frequency;

    fn div(self, rhs: Time) -> Self::Output {
        Frequency::from_raw(self / rhs.as_f64())
    }
}

impl Div<Frequency> for f64 {
    type Output = Time;

    fn div(self, rhs: Frequency) -> Self::Output {
        Time::from_raw(self / rhs.as_f64())
    }
}

#[cfg(feature = "pyo3")]
#[pyo3::pymethods]
impl Time {
    fn __rtruediv__(rhs: pyo3::PyRef<Self>, lhs: f64) -> pyo3::PyResult<Frequency> {
        Ok(lhs / *rhs)
    }
}

#[cfg(feature = "pyo3")]
#[pyo3::pymethods]
impl Frequency {
    fn __rtruediv__(rhs: pyo3::PyRef<Self>, lhs: f64) -> pyo3::PyResult<Time> {
        Ok(lhs / *rhs)
    }
}