dims_core 0.5.1

Core Utils for Generating Units and Systems
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;
use core::fmt;
use {MeasureSystem as MS, UnitTrait as UT};

use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};

/// Measure is a wrapped Measurement of a specific System.
///
/// The value is stored in the base unit of the given system. (EX: Metre for length)
///
/// This is `#[repr(transparent)]`, so when compiled,
/// the memory footprint is that of the underlying Float
#[repr(transparent)]
#[derive(Copy, Clone, PartialEq, PartialOrd, Default)]
pub struct Measure<S: MS> {
    pub val: S::N,
}

impl<S: MS> Measure<S> {
    /// Generate a new Measure from the given unit and val
    pub fn new<U: UT<System = S>>(unit: &U, val: S::N) -> Self {
        let val = unit.to_base(val);
        Self { val }
    }
    /// Convert the stored value to the provided one
    pub fn val_as<U: UT<System = S>>(self, unit: &U) -> S::N {
        unit.to_self(self.val)
    }
    /// Return the stored value in its base unit
    pub fn as_base(self) -> S::N {
        self.val
    }
}
// Section: ops

#[opimps::impl_ops(Add)]
fn add<S: MS>(self: Measure<S>, two: Measure<S>) -> Measure<S> {
    Measure {
        val: self.val.clone() + two.val.clone(),
    }
}
#[opimps::impl_ops_assign(AddAssign)]
fn add_assign<S: MS>(self: Measure<S>, two: Measure<S>) {
    self.val = self.val.clone() + two.val.clone();
}
#[opimps::impl_ops(Sub)]
fn sub<S: MS>(self: Measure<S>, two: Measure<S>) -> Measure<S> {
    Measure {
        val: self.val.clone() - two.val.clone(),
    }
}
#[opimps::impl_ops_assign(SubAssign)]
fn sub_assign<S: MS>(self: Measure<S>, two: Measure<S>) {
    self.val = self.val.clone() - two.val.clone();
}
// Impls for multiplying and dividing by primitives or external types
#[opimps::impl_ops_rprim(Mul)]
fn mul<N: NumTrait, S: MS<N = N>>(self: Measure<S>, other: N) -> Measure<S> {
    Measure {
        val: self.val.clone() * other.clone(),
    }
}
#[opimps::impl_op_assign(MulAssign)]
fn mul_assign<N: NumTrait, S: MS<N = N>>(self: Measure<S>, other: N) {
    self.val = self.val.clone() * other;
}

#[opimps::impl_ops_rprim(Div)]
fn div<N: NumTrait, S: MS<N = N>>(self: Measure<S>, other: N) -> Measure<S> {
    Measure {
        val: self.val.clone() / other.clone(),
    }
}
#[opimps::impl_op_assign(DivAssign)]
fn div_assign<N: NumTrait, S: MS<N = N>>(self: Measure<S>, other: N) {
    self.val = self.val.clone() / other;
}
// Section: Conditonal Impls

#[opimps::impl_ops(Mul)]
fn mul<N: NumTrait, S1: MS, S2: MS>(self: Measure<S1>, other: Measure<S2>) -> Measure<S1::Output>
where
    S1: MS<N = N> + MultiplyBy<S2>,
    S2: MS<N = N>,
{
    Measure {
        val: self.val.clone() * other.val.clone(),
    }
}

#[opimps::impl_ops(Div)]
fn div<N: NumTrait, S1: MS, S2: MS>(self: Measure<S1>, other: Measure<S2>) -> Measure<S1::Output>
where
    S1: MS<N = N> + DivideBy<S2>,
    S2: MS<N = N>,
{
    Measure {
        val: self.val.clone() / other.val.clone(),
    }
}

impl<N: NumTrait + Neg<Output = N>, S: MS<N = N>> Neg for Measure<S> {
    type Output = Self;
    fn neg(self) -> Self::Output {
        Self { val: -self.val }
    }
}

impl<S: MS + Clone> fmt::Debug for Measure<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        #[cfg(feature = "str")]
        {
            let val = { S::DEBUG_UNIT.as_string_abbr(self.clone()) };
            f.write_str(&val)
        }
        #[cfg(not(feature = "str"))]
        {
            f.debug_struct("Measure")
                .field("as_base", &self.val)
                .finish()
        }
    }
}