unitforge 0.5.3

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

use crate::common::approx_eq;
use unitforge::quantities::*;
use unitforge::PhysicsQuantity;

const C: Velocity = Velocity::c();
const G: Acceleration = Acceleration::g();
const PI: Angle = Angle::pi();
const R: UniversalGasConstant = UniversalGasConstant::r();
const AMERICIUM: Density = Density::americium();
const WATER_VAPOR_PRESSURE: Stress = Stress::new(0.0627, StressUnit::bar);
const TEMP: Temperature = Temperature::new(-1.0, TemperatureUnit::K);
const R_FROM_NEW: UniversalGasConstant =
    UniversalGasConstant::new(8.31446261815324, UniversalGasConstantUnit::J_molK);

#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
const LARGE_GPA_STRESS: Stress = Stress::new(1.0e308, StressUnit::GPa);

#[cfg(feature = "storage-f32")]
const C_TOLERANCE: f64 = 16.0;
#[cfg(not(feature = "storage-f32"))]
const C_TOLERANCE: f64 = 1e-6;

#[cfg(feature = "storage-f32")]
const STRICT_TOLERANCE: f64 = 1e-5;
#[cfg(not(feature = "storage-f32"))]
const STRICT_TOLERANCE: f64 = 1e-12;

#[cfg(feature = "storage-f32")]
const DENSITY_TOLERANCE: f64 = 1e-2;
#[cfg(not(feature = "storage-f32"))]
const DENSITY_TOLERANCE: f64 = 1e-8;

#[test]
fn named_constants_are_const_compatible() {
    assert!(approx_eq(
        C.to(VelocityUnit::m_s),
        299_792_458.0,
        C_TOLERANCE
    ));
    assert!(approx_eq(
        G.to(AccelerationUnit::m_ssq),
        9.81,
        STRICT_TOLERANCE
    ));
    assert!(approx_eq(
        PI.to(AngleUnit::rad),
        core::f64::consts::PI,
        STRICT_TOLERANCE
    ));
    assert!(approx_eq(
        R.to(UniversalGasConstantUnit::J_molK),
        8.31446261815324,
        STRICT_TOLERANCE
    ));
}

#[test]
fn const_constants_preserve_values_for_normalized_inputs() {
    assert!(approx_eq(
        AMERICIUM.to(DensityUnit::kg_mcb),
        120_000.0,
        DENSITY_TOLERANCE
    ));
}

#[test]
fn quantity_constructors_are_const_compatible() {
    assert!(approx_eq(
        WATER_VAPOR_PRESSURE.to(StressUnit::Pa),
        6270.0,
        STRICT_TOLERANCE
    ));
    assert!(approx_eq(
        WATER_VAPOR_PRESSURE.to(StressUnit::bar),
        0.0627,
        STRICT_TOLERANCE
    ));
    assert!(approx_eq(
        TEMP.to(TemperatureUnit::K),
        -1.0,
        STRICT_TOLERANCE
    ));
    assert!(approx_eq(
        R_FROM_NEW.to(UniversalGasConstantUnit::J_molK),
        8.31446261815324,
        STRICT_TOLERANCE
    ));
}

#[test]
#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
fn const_constructors_preserve_large_exponential_parts() {
    let runtime = Stress::new(1.0e308, StressUnit::GPa);
    let (const_multiplier, const_power) = LARGE_GPA_STRESS.get_tuple();
    let (runtime_multiplier, runtime_power) = runtime.get_tuple();

    assert!(const_multiplier.is_finite());
    assert!(approx_eq(const_multiplier, runtime_multiplier, 1e-12));
    assert_eq!(const_power, runtime_power);
}

#[test]
#[cfg(not(any(feature = "storage-f64", feature = "storage-f32")))]
fn const_constants_preserve_canonical_parts_for_normalized_inputs() {
    let (multiplier, power) = AMERICIUM.get_tuple();

    assert!(approx_eq(multiplier, 1.2, 1e-12));
    assert_eq!(power, 5);
}