dana 0.4.0

Compile-time dimensional analysis via generic types.
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

//! Module for [compound unit](UnitCompound) types.
//!
//! Compound units are defined in terms of other units. Each compound unit type
//!     is generic over one or more [`Unit`] types (which may themselves also be
//!     compound units), and represents a relationship between them. A compound
//!     unit defines its [`Dim`](Unit::Dim) type and [scale](Unit::scale) based
//!     on those of its components.

use super::traits::*;

mod serde;

mod per_unit;
mod unit_div;
mod unit_mul;
mod unit_pow;

pub use per_unit::PerUnit;
pub use unit_div::UnitDiv;
pub use unit_mul::UnitMul;
pub use unit_pow::*;


// /// Module to re-export all compound unit types.
// pub mod types {
//     pub use super::{PerUnit, UnitDiv, UnitMul, unit_pow::*};
// }


/// Operator implementations grouped together, to compare them more easily.
mod impl_ops {
    use core::ops::{Div, Mul};
    use num_traits::Inv;
    use typenum::Integer;
    use crate::{dimension::*, units::compound::*};

    //region `Div`/`Mul` impls.
    macro_rules! impl_div_mul {
        ($($name:ident $(<$(
        $param:ident $(: $bound:ident)?
        ),*>)?),* $(,)?) => {
            $(impl<$($($param $(: $bound)?,)*)? __W: Unit>
            Div<__W> for $name$(<$($param),*>)? where Self: CanUnitDiv<__W> {
                type Output = UnitDiv<Self, __W>;

                fn div(self, rhs: __W) -> Self::Output {
                    Self::Output::new(self, rhs)
                }
            })*

            $(impl<$($($param $(: $bound)?,)*)? __W: Unit>
            Mul<__W> for $name$(<$($param),*>)? where Self: CanUnitMul<__W> {
                type Output = UnitMul<Self, __W>;

                fn mul(self, rhs: __W) -> Self::Output {
                    Self::Output::new(self, rhs)
                }
            })*
        };
    }

    impl_div_mul!(
        PerUnit<U: Unit>,
        UnitDiv<A: Unit, B: Unit>,
        UnitMul<A: Unit, B: Unit>,
        UnitPow<U: Unit, E: Integer>,
    );
    //endregion

    //region `Inv` impls.
    macro_rules! impl_inv {
        ($($name:ident $(<$(
        $param:ident $(: $bound:ident)?
        ),*>)?),* $(,)?) => {
            $(impl$(<$($param $(: $bound)?),*>)?
            Inv for $name$(<$($param),*>)? where Self: CanUnitInv {
                type Output = PerUnit<Self>;

                fn inv(self) -> Self::Output {
                    Self::Output::new(self)
                }
            })*
        };
    }

    impl_inv!(
        PerUnit<U: Unit>,
        // UnitDiv<A: Unit, B: Unit>,
        UnitMul<A: Unit, B: Unit>,
        UnitPow<U: Unit, E: Integer>,
    );

    impl<A: Unit, B: Unit> Inv for UnitDiv<A, B> {
        type Output = UnitDiv<B, A>;

        fn inv(self) -> Self::Output {
            Self::Output::new(self.1, self.0)
        }
    }
    //endregion

    //region `CanPow` impls.
    macro_rules! impl_pow {
        ($($name:ident $(<$(
        $param:ident $(: $bound:ident)?
        ),*>)?),* $(,)?) => {
            $(impl<$($($param $(: $bound)?,)*)? const __E: i32>
            CanPow<__E> for $name$(<$($param),*>)? where
                Exponent<__E>: HasTypenum,
                Self: Unit,
                Self::Dim: CanDimPowType<<Exponent<__E> as HasTypenum>::Typenum>,
            {
                type Output = UnitPowN<Self, __E>;

                fn pow(self) -> Self::Output {
                    Self::Output::new(self)
                }
            })*
        };
    }

    impl_pow!(
        PerUnit<U: Unit>,
        UnitDiv<A: Unit, B: Unit>,
        UnitMul<A: Unit, B: Unit>,
        // UnitPow<U: Unit, E: Integer>,
    );
    //endregion
}