mechanical-engineering 0.0.0

Mechanical engineering calculation library and terminal based GUI
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

use crate::errors::EngCalcError;

#[derive(Debug, Clone)]
pub enum Unit {
    Psi,
    Kpa,
    Pa,
    Bar,
}

fn conversion_kpa(unit: &Unit) -> f32 {
    match unit {
        Unit::Psi => 0.14503774,
        Unit::Kpa => 1.0,
        Unit::Pa => 1000.0,
        Unit::Bar => 0.01,
    }
}

fn convert(from_value: f32, from_unit: &Unit, to_unit: &Unit) -> f32 {
    let from_conversion = conversion_kpa(from_unit);
    let to_conversion = conversion_kpa(to_unit);
    from_value * to_conversion / from_conversion
}

#[derive(Debug, Clone)]
pub struct Pressure {
    value: f32,
    unit: Unit,
    absolute: bool,
}

impl Pressure {
    pub fn new(value: f32, unit: Unit, absolute: bool) -> Self {
        Pressure {
            value,
            unit,
            absolute,
        }
    }

    pub fn value(&self) -> f32 {
        self.value
    }

    pub fn unit(&self) -> Unit {
        self.unit.clone()
    }

    pub fn is_absolute(&self) -> bool {
        self.absolute
    }

    pub fn convert_unit(&mut self, new_unit: Unit) {
        let new_value = convert(self.value, &self.unit, &new_unit);
        self.value = new_value;
        self.unit = new_unit;
    }

    pub fn pressure_ratio(p1: &Pressure, p2: &Pressure) -> Result<f32, EngCalcError> {
        if !p1.is_absolute() || !p2.is_absolute() {
            return Err(EngCalcError::InvalidUnits(
                "Pressure ratio calculation must use absolute units.",
            ));
        }

        let p1_value_kpa = convert(p1.value, &p1.unit, &Unit::Kpa);
        let p2_value_kpa = convert(p2.value, &p2.unit, &Unit::Kpa);
        Ok(p2_value_kpa / p1_value_kpa)
    }

    pub fn add_pressure(self, other: &Pressure) -> Self {
        let p2_value_conv = convert(other.value, &other.unit, &self.unit());
        let total_pressure = self.value() + p2_value_conv;
        Pressure {
            value: total_pressure,
            unit: self.unit,
            absolute: self.absolute,
        }
    }

    pub fn subtract_pressure(self, other: &Pressure) -> Self {
        let p2_value_conv = convert(other.value, &other.unit, &self.unit());
        let total_pressure = self.value() - p2_value_conv;
        Pressure {
            value: total_pressure,
            unit: self.unit,
            absolute: self.absolute,
        }
    }
}