danwi 0.4.2

Zero-cost dimensional analysis library with SI units, compile-time checking, and no_std support
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
124
125
126
127
128
129
130
131
132
133
134
135

use super::{Quantity, fmt::UnitDisplay};
use crate::{
    dimension::{Dimensionless, Dimensions},
    scalar::Scalar,
    unit::{Unit, UnitDef},
};
use core::marker::PhantomData;

impl<S: Scalar, D: Dimensions> From<S> for Quantity<S, D> {
    /// Wraps a raw scalar already expressed in the SI base unit; equivalent
    /// to [`Quantity::from_base`].
    #[inline(always)]
    fn from(value: S) -> Self {
        Self::from_base(value)
    }
}

// A dimensionless quantity (e.g. the ratio of two voltages) converts back
// into its bare scalar.

#[cfg(feature = "f32")]
impl From<Quantity<f32, Dimensionless>> for f32 {
    #[inline(always)]
    fn from(q: Quantity<f32, Dimensionless>) -> Self {
        q.value
    }
}

#[cfg(feature = "f64")]
impl From<Quantity<f64, Dimensionless>> for f64 {
    #[inline(always)]
    fn from(q: Quantity<f64, Dimensionless>) -> Self {
        q.value
    }
}

#[cfg(feature = "f32")]
impl<D: Dimensions> Quantity<f32, D> {
    /// Construct from a raw base-unit scalar in a `const` context.
    #[inline(always)]
    pub const fn from_f32(value: f32) -> Self {
        Self::from_base(value)
    }

    /// Construct from a value expressed in the given unit.
    ///
    /// Equivalent to `value * unit`, but usable in `const` contexts.
    #[inline(always)]
    pub const fn new<M: UnitDef<Dim = D>>(value: f32, _unit: Unit<M>) -> Self {
        Self::from_base(crate::scalar::to_base_f32(
            value,
            M::SCALE_NUM,
            M::SCALE_DEN,
            M::OFFSET_NUM,
            M::OFFSET_DEN,
        ))
    }

    /// Extract the value expressed in the given unit.
    ///
    /// All arithmetic happens at the unit's const scale factor, so with
    /// const-known inputs this folds away entirely at compile time.
    #[inline(always)]
    pub const fn to<M: UnitDef<Dim = D>>(self, _unit: Unit<M>) -> f32 {
        crate::scalar::from_base_f32(
            self.value,
            M::SCALE_NUM,
            M::SCALE_DEN,
            M::OFFSET_NUM,
            M::OFFSET_DEN,
        )
    }

    /// Wrap the quantity for formatting in the given unit.
    ///
    /// Calling `display_as` does no work; it only packages the value and
    /// the unit for a later `Display` call.
    #[inline(always)]
    pub const fn display_as<M: UnitDef<Dim = D>>(self, _unit: Unit<M>) -> UnitDisplay<f32, M> {
        UnitDisplay {
            value: self.value,
            _phantom: PhantomData,
        }
    }
}

#[cfg(feature = "f64")]
impl<D: Dimensions> Quantity<f64, D> {
    /// Construct from a raw base-unit scalar in a `const` context.
    #[inline(always)]
    pub const fn from_f64(value: f64) -> Self {
        Self::from_base(value)
    }

    /// Construct from a value expressed in the given unit.
    ///
    /// Equivalent to `value * unit`, but usable in `const` contexts.
    #[inline(always)]
    pub const fn new<M: UnitDef<Dim = D>>(value: f64, _unit: Unit<M>) -> Self {
        Self::from_base(crate::scalar::to_base_f64(
            value,
            M::SCALE_NUM,
            M::SCALE_DEN,
            M::OFFSET_NUM,
            M::OFFSET_DEN,
        ))
    }

    /// Extract the value expressed in the given unit.
    ///
    /// All arithmetic happens at the unit's const scale factor, so with
    /// const-known inputs this folds away entirely at compile time.
    #[inline(always)]
    pub const fn to<M: UnitDef<Dim = D>>(self, _unit: Unit<M>) -> f64 {
        crate::scalar::from_base_f64(
            self.value,
            M::SCALE_NUM,
            M::SCALE_DEN,
            M::OFFSET_NUM,
            M::OFFSET_DEN,
        )
    }

    /// Wrap the quantity for formatting in the given unit.
    ///
    /// Calling `display_as` does no work; it only packages the value and
    /// the unit for a later `Display` call.
    #[inline(always)]
    pub const fn display_as<M: UnitDef<Dim = D>>(self, _unit: Unit<M>) -> UnitDisplay<f64, M> {
        UnitDisplay {
            value: self.value,
            _phantom: PhantomData,
        }
    }
}