unitforge 0.3.19

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

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))]
pub enum DistanceUnit {
    km,
    m,
    dm,
    cm,
    mm,
    um,
    nm,
    mi,
    yd,
    ft,
    inch,
    planck,
    fm,
    an,
    AU,
    ly,
    pc,
    kpc,
    Mpc,
    Gpc,
    solar_radius,
    earth_radius,
    lunar_radius,
    jupiter_radius,
}

impl PhysicsUnit for DistanceUnit {
    fn name(&self) -> &str {
        match &self {
            DistanceUnit::km => "km",
            DistanceUnit::m => "m",
            DistanceUnit::dm => "dm",
            DistanceUnit::cm => "cm",
            DistanceUnit::mm => "mm",
            DistanceUnit::um => "μm",
            DistanceUnit::nm => "nm",
            DistanceUnit::mi => "mi",
            DistanceUnit::yd => "yd",
            DistanceUnit::ft => "ft",
            DistanceUnit::inch => "in",
            DistanceUnit::planck => "Planck Distance",
            DistanceUnit::fm => "fm",
            DistanceUnit::an => "Å",
            DistanceUnit::AU => "AU",
            DistanceUnit::ly => "ly",
            DistanceUnit::pc => "py",
            DistanceUnit::kpc => "kpc",
            DistanceUnit::Mpc => "MPc",
            DistanceUnit::Gpc => "GPc",
            DistanceUnit::solar_radius => "M☉",
            DistanceUnit::earth_radius => "M⊕",
            DistanceUnit::lunar_radius => "M☽",
            DistanceUnit::jupiter_radius => "M♃",
        }
    }

    fn base_per_x(&self) -> (f64, i32) {
        match self {
            DistanceUnit::km => (1.0, 3),
            DistanceUnit::m => (1.0, 0),
            DistanceUnit::dm => (1.0, -1),
            DistanceUnit::cm => (1.0, -2),
            DistanceUnit::mm => (1.0, -3),
            DistanceUnit::um => (1.0, -6),
            DistanceUnit::nm => (1.0, -9),
            DistanceUnit::mi => (1.609344, 3),
            DistanceUnit::yd => (9.144, -1),
            DistanceUnit::ft => (3.048, -1),
            DistanceUnit::inch => (2.54, -2),
            DistanceUnit::planck => (1.616255, -35),
            DistanceUnit::fm => (1., -15),
            DistanceUnit::an => (1., -10),
            DistanceUnit::AU => (1.49597870700, 11),
            DistanceUnit::ly => (Time::new(1., TimeUnit::year) * Velocity::c()).get_tuple(),
            DistanceUnit::pc => (3.085677581, 16),
            DistanceUnit::kpc => (3.085677581, 16 + 3),
            DistanceUnit::Mpc => (3.085677581, 16 + 6),
            DistanceUnit::Gpc => (3.085677581, 16 + 9),
            DistanceUnit::solar_radius => (6.957, 8),
            DistanceUnit::earth_radius => (6.3781, 6),
            DistanceUnit::lunar_radius => (1.738, 6),
            DistanceUnit::jupiter_radius => (7.1492, 7),
        }
    }
}

impl_const!(Distance, a_0, 5.29177210544, -11);
impl_const!(Distance, r_e, 2.8179403227, -15);

impl_quantity!(Distance, DistanceUnit, [DistanceUnit::mm]);
impl_div_with_self_to_f64!(Distance);

impl_mul!(Distance, Strain, Distance);