mag 0.6.0

Physical quantities and units
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

// temp.rs
//
// Copyright (C) 2019-2021  Minnesota Department of Transportation
// Copyright (C) 2019-2021  Douglas P Lau
//
//! Units of thermodynamic temperature.
//!
//! Each unit is defined relative to degrees Kelvin with a conversion factor and
//! zero point.  They can be used to conveniently create [Temperature] structs.
//!
//! ## Example
//!
//! ```rust
//! use mag::temp::{DegC, DegF};
//!
//! let a = 22.8 * DegC;
//! let b = 98.6 * DegF;
//!
//! assert_eq!(a.to_string(), "22.8 °C");
//! assert_eq!(b.to_string(), "98.6 °F");
//! assert_eq!(b.to(), 37 * DegC);
//! ```
//!
//! # Example: Delisle
//! ```rust
//! use approx::assert_relative_eq;
//! use mag::{declare_unit, temp::DegC, quan::Temperature};
//!
//! declare_unit!(Delisle, "°D", Temperature, -2.0 / 3.0, 559.73,);
//!
//! let boiling = 0 * Delisle;
//! assert_eq!(boiling.to_string(), "0 °D");
//! assert_relative_eq!(
//!     boiling.to::<DegC>().value,
//!     100.0,
//!     max_relative = 0.000_1
//! );
//! let freezing = 0 * DegC;
//! assert_relative_eq!(
//!     freezing.to::<Delisle>().value,
//!     150.0,
//!     max_relative = 0.000_1
//! );
//! ```
use crate::declare_unit;
use crate::quan::Temperature;

declare_unit!(
    /** Degrees Celsius / Centigrade */
    DegC,
    "°C",
    Temperature,
    1.0,
    -273.15,
);

declare_unit!(
    /** Degrees Kelvin */
    DegK,
    "°K",
    Temperature,
    1.0,
    0.0,
);

declare_unit!(
    /** Degrees Fahrenheit */
    DegF,
    "°F",
    Temperature,
    5.0 / 9.0,
    -459.67,
);

declare_unit!(
    /** Degrees Rankine */
    DegR,
    "°R",
    Temperature,
    5.0 / 9.0,
    0.0,
);

declare_unit!(
    /** Degrees Réaumur */
    DegRe,
    "°Ré",
    Temperature,
    0.8,
    -273.15,
);

#[cfg(test)]
mod test {
    extern crate alloc;

    use super::*;
    use alloc::{format, string::ToString};

    #[test]
    fn temp_display() {
        assert_eq!((22.4 * DegC).to_string(), "22.4 °C");
        assert_eq!((-5.2 * DegF).to_string(), "-5.2 °F");
        assert_eq!(format!("{:.1}", 111.1111 * DegK), "111.1 °K");
        assert_eq!(format!("{:.2}", (32.0 * DegF).to::<DegC>()), "0.00 °C");
    }

    #[test]
    fn temp_to() {
        assert_eq!((32.0 * DegF).to(), 0.00000000000005684341886080802 * DegC);
        assert_eq!((0.0 * DegC).to(), 31.999999999999943 * DegF);
        assert_eq!((212.0 * DegF).to(), 100.00000000000006 * DegC);
        assert_eq!((100.0 * DegC).to(), 211.99999999999994 * DegF);
        assert_eq!((-273.15 * DegC).to(), 0.0 * DegK);
        assert_eq!((0.0 * DegK).to(), -273.15 * DegC);
    }

    #[test]
    fn temp_add() {
        assert_eq!(10.0 * DegF + 5.5 * DegF, 15.5 * DegF);
        assert_eq!(20.0 * DegC + 6.2 * DegC, 26.2 * DegC);
    }

    #[test]
    fn temp_sub() {
        assert_eq!(70.0 * DegF - 15.6 * DegF, 54.4 * DegF);
        assert_eq!(40.0 * DegC - 16.1 * DegC, 23.9 * DegC);
    }
}