unitforge 0.3.19

A library for unit and quantity consistent computations in Rust
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

#![cfg(test)]
mod tests {
    use crate::*;
    use num_traits::Zero;

    #[test]
    fn test_new() {
        let input = 1000;
        let output = Distance::new(input.into(), DistanceUnit::mm);
        assert_eq!(
            output,
            Distance {
                multiplier: 1000f64,
                power: -3
            }
        )
    }

    #[test]
    fn optimize_on_add() {
        let f_1 = Force::new(10.0, ForceUnit::N);
        let f_2 = Force::new(1.0E12, ForceUnit::N);
        let f = f_1 + f_2;
        assert!(f.get_multiplier().log10().round() == 0.);
    }

    #[test]
    fn optimize_large() {
        let mut x = Force {
            multiplier: 1E10,
            power: 0,
        };
        x.optimize();
        assert!(x.get_multiplier().log10().round() == 0.);
        assert_eq!(x.to(ForceUnit::N), 1E10);
    }

    #[test]
    fn optimize_small() {
        let mut x = Force {
            multiplier: 1E-10,
            power: 0,
        };
        x.optimize();
        assert!(x.get_multiplier().log10().round() == 0.);
        assert_eq!(x.to(ForceUnit::N), 1E-10);
    }

    #[test]
    fn optimize_zero() {
        let mut f_1 = Force::zero();
        f_1.optimize();
        assert_eq!(f_1, Force::zero());
    }

    #[test]
    fn mul_with_self() {
        let a = Quantity::AreaQuantity(Area::new(10.0, AreaUnit::msq));
        let b = (a * a).unwrap();
        assert_eq!(
            b.to(Unit::AreaOfMomentUnit(AreaOfMomentUnit::mhc)).unwrap(),
            100.0
        );
    }

    #[test]
    fn sqrt() {
        let a = Quantity::AreaOfMomentQuantity(AreaOfMoment::new(25.0, AreaOfMomentUnit::mhc));
        let b = a.sqrt().unwrap();
        assert!((b.to(Unit::AreaUnit(AreaUnit::msq)).unwrap() - 5.0).abs() < 1E-10);
    }

    #[test]
    fn inverse_stress_from_stress_division() {
        let stress = Stress::new(2.0, StressUnit::Pa);
        let inverse = 1.0 / stress;
        assert!((inverse.to(InverseStressUnit::_Pa) - 0.5).abs() < 1E-12);
    }

    #[test]
    fn stress_from_inverse_stress_division() {
        let inverse = InverseStress::new(0.5, InverseStressUnit::_Pa);
        let stress = 1.0 / inverse;
        assert!((stress.to(StressUnit::Pa) - 2.0).abs() < 1E-12);
    }

    #[test]
    fn stress_squared_from_force_stress_over_area() {
        let force = Force::new(2.0, ForceUnit::N);
        let stress = Stress::new(3.0, StressUnit::Pa);
        let area = Area::new(6.0, AreaUnit::msq);
        let result = (force * stress) / area;
        assert!((result.to(StressSquaredUnit::Nsq_mmhc) - 1.0).abs() < 1E-12);
    }

    #[test]
    fn force_stress_from_stress_squared_times_area() {
        let stress_squared = StressSquared::new(2.0, StressSquaredUnit::Nsq_mmhc);
        let area = Area::new(3.0, AreaUnit::msq);
        let result = stress_squared * area;
        assert!((result.to(ForceStressUnit::Nsq_msq) - 6.0).abs() < 1E-12);
    }

    #[test]
    fn test_optimal_unit_with_selection() {
        let area = Area::new(0.0001, AreaUnit::msq);
        let optimal_unit = area
            .optimal_unit(
                vec![AreaUnit::kmsq, AreaUnit::cmsq, AreaUnit::nmsq]
                    .into_iter()
                    .collect::<std::collections::HashSet<_>>(),
            )
            .unwrap();
        assert_eq!(optimal_unit, AreaUnit::cmsq)
    }
}