metrum 1.1.0

Easily work with and compare temeratures in different 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

pub mod cmp;
pub mod sub;

#[cfg(feature = "wasm")]
use wasm_bindgen::prelude::*;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "wasm", wasm_bindgen)]
pub struct Temp {
    kelvin: f64,
}

#[cfg_attr(feature = "wasm", wasm_bindgen)]
impl Temp {
    pub fn from_c(val: f64) -> Self {
        Self {
            kelvin: val + 273.15,
        }
    }

    pub fn from_f(val: f64) -> Self {
        Self {
            kelvin: (val - 32.) * (5. / 9.) + 273.15,
        }
    }

    pub fn from_k(val: f64) -> Self {
        Self { kelvin: val }
    }

    pub fn as_c(&self) -> f64 {
        self.kelvin - 273.15
    }

    pub fn as_f(&self) -> f64 {
        let c = self.as_c();

        c * (9. / 5.) + 32.
    }

    pub fn as_k(&self) -> f64 {
        self.kelvin
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use std::vec;

    #[derive(Debug, Serialize, Deserialize)]
    struct Conversion {
        celsius: f64,
        fahrenheit: f64,
        kelvin: f64,
    }

    #[test]
    fn should_convert_correctly() {
        let temps = vec![
            Conversion {
                celsius: 0.,
                fahrenheit: 32.,
                kelvin: 273.15,
            },
            Conversion {
                celsius: 10.,
                fahrenheit: 50.,
                kelvin: 283.15,
            },
        ];

        for temp in temps {
            let f_source = Temp::from_f(temp.fahrenheit);
            let c_source = Temp::from_c(temp.celsius);
            let k_source = Temp::from_k(temp.kelvin);

            // convert to celcius
            assert_eq!(f_source.as_c(), temp.celsius);
            assert_eq!(k_source.as_c(), temp.celsius);

            // convert to farenheit
            assert_eq!(c_source.as_f(), temp.fahrenheit);
            assert_eq!(k_source.as_f(), temp.fahrenheit);

            // convert to kelvin
            assert_eq!(c_source.as_k(), temp.kelvin);
            assert_eq!(f_source.as_k(), temp.kelvin);
        }
    }
}