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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Module for [concrete unit](UnitConcrete) types.
//!
//! Concrete units are defined absolutely, and are not reducible, but they may
//!     have multiple variants with different scale factors. Every concrete unit
//!     type has a constant [base unit](UnitConcrete::BASE), and every concrete
//!     unit has a unique [symbol](UnitConcrete::symbol).

#![allow(missing_docs)]

use core::ops::{Div, Mul};
use crate::{
    dimension::{CanDimPowType, Exponent, HasTypenum},
    units::{compound::*, traits::*},
};


/// # New Unit Checklist
/// 1. Source file.
/// 2. Add to `concrete_types!` and `impl_scale!` calls below.
/// 3. Add to [`crate::symbols`].
struct _Notes;


macro_rules! concrete_mod {
    //  Doc comment provided, use it directly.
    ($(#[$attr:meta])+ $vis:vis use $module:ident::$unit:ident;) => {
        $(#[$attr])+
        mod $module;
        $vis use $module::$unit;
    };
    //  Doc comment not provided, generate one.
    ($vis:vis use $module:ident::$unit:ident;) => {
        #[doc = concat!(
            "Module for the ",
            "[`", stringify!($unit), "`]",
            "(", stringify!($module), "::", stringify!($unit), ")",
            " concrete unit type.",
        )]
        mod $module;
        $vis use $module::$unit;
    };
}

macro_rules! concrete_types {
    ($(
    $(#[$attr:meta])*
    $module:ident::$unit:ident
    ),+$(,)?) => {
        $(concrete_mod! {
            $(#[$attr])*
            pub use $module::$unit;
        })+

        // /// Module to re-export all concrete unit types.
        // pub mod types {
        //     pub use super::{$($module::$unit,)+};
        // }

        $(
        impl Default for $unit {
            fn default() -> Self { Self::BASE }
        }

        impl ::core::fmt::Display for $unit {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                <str as core::fmt::Display>::fmt(self.symbol(), f)
            }
        }

        //  Unit division.
        impl<U: Unit> Div<U> for $unit where Self: CanUnitDiv<U> {
            type Output = UnitDiv<Self, U>;

            fn div(self, rhs: U) -> Self::Output {
                UnitDiv::new(self, rhs)
            }
        }

        //  Unit multiplication.
        impl<U: Unit> Mul<U> for $unit where Self: CanUnitMul<U> {
            type Output = UnitMul<Self, U>;

            fn mul(self, rhs: U) -> Self::Output {
                UnitMul::new(self, rhs)
            }
        }

        //  Unit inversion.
        impl ::num_traits::Inv for $unit where Self: CanUnitInv {
            type Output = PerUnit<Self>;

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

        //  Unit exponentiation.
        impl<const E: i32> CanPow<E> for $unit where
            Exponent<E>: HasTypenum,
            Self::Dim: CanDimPowType<<Exponent<E> as HasTypenum>::Typenum>,
        {
            type Output = UnitPow<Self, <Exponent<E> as HasTypenum>::Typenum>;

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

concrete_types!(
    one::One,

    length::Length,
    mass::Mass,
    time::Time,
    frequency::Frequency,

    temp::Temp,
    amount::Amount,
    intensity::Intensity,

    force::Force,
    volume::Volume,
    pressure::Pressure,

    energy::Energy,
    power::Power,
    charge::Charge,
    current::Current,
    voltage::Voltage,
    resistance::Resistance,
);


/*impl_scale! {
    for Length impl (Pico, Nano, Micro, Milli, Kilo) Meter;
    // for Mass impl (Milli, Kilo) Gram;
    for Time impl (Pico, Nano, Micro, Milli) Second;
    for Frequency impl (Micro, Milli, Kilo, Mega, Giga, Tera) Hertz;

    for Temp impl (Micro, Milli, Kilo, Mega, Giga, Tera) Kelvin;
    for Amount impl (Micro, Milli, Kilo, Mega, Giga, Tera) Mole;
    for Intensity impl (Micro, Milli, Kilo, Mega, Giga, Tera) Candela;

    for Force impl (Kilo, Mega, Giga) Newton;
    for Volume impl (Micro, Milli, Kilo, Mega, Giga, Tera) Liter;
    for Pressure impl (Micro, Milli, Kilo, Mega, Giga, Tera) Pascal;

    for Energy impl (Micro, Milli, Kilo, Mega, Giga, Tera) Joule;
    for Power impl (Micro, Milli, Kilo, Mega, Giga, Tera) Watt;
    for Charge impl (Micro, Milli, Kilo, Mega, Giga, Tera) Coulomb;
    for Current impl (Micro, Milli, Kilo, Mega, Giga, Tera) Amp;
    for Voltage impl (Micro, Milli, Kilo, Mega, Giga, Tera) Volt;
    for Resistance impl (Micro, Milli, Kilo, Mega, Giga, Tera) Ohm;
}*/