unitforge 0.4.1

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

use crate::common::approx_eq;
use unitforge::quantities::{
    Area, AreaOfMoment, AreaOfMomentUnit, AreaUnit, DistanceUnit, Force, ForceStressUnit,
    ForceUnit, InverseStress, InverseStressUnit, Stress, StressSquared, StressSquaredUnit,
    StressUnit,
};
use unitforge::{PhysicsQuantity, Quantity, Sqrt, Unit};

#[test]
fn mul_with_self() {
    let area = Quantity::AreaQuantity(Area::new(10.0, AreaUnit::msq));
    let area_of_moment = (area * area).unwrap();

    assert_eq!(
        area_of_moment
            .to(Unit::AreaOfMomentUnit(AreaOfMomentUnit::mhc))
            .unwrap(),
        100.0
    );
}

#[test]
fn sqrt_of_area_of_moment_returns_area() {
    let area_of_moment =
        Quantity::AreaOfMomentQuantity(AreaOfMoment::new(25.0, AreaOfMomentUnit::mhc));
    let area = area_of_moment.sqrt().unwrap();

    assert!((area.to(Unit::AreaUnit(AreaUnit::msq)).unwrap() - 5.0).abs() < 1e-10);
}

#[test]
fn sqrt_handles_odd_decimal_power() {
    let area = Area::from_exponential(9.0, 1);
    let distance = area.sqrt();

    assert!((distance.to(DistanceUnit::m) - 90.0f64.sqrt()).abs() < 1e-12);
}

#[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!(approx_eq(result.to(StressSquaredUnit::Nsq_mmhc), 1.0, 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!(approx_eq(result.to(ForceStressUnit::Nsq_msq), 6.0, 1e-12));
}