ionex 0.1.0

IONEX (Ionosphere Maps) parser
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
117
118

#[cfg(doc)]
use crate::{coordinates::QuantizedCoordinates, prelude::TEC};

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

use std::cmp::Ordering;

/// [Quantized] value representing either a [TEC] estimate,
/// or discrete coordinates as [QuantizedCoordinates].
#[derive(Debug, Default, Copy, Clone, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Quantized {
    /// Exponent (scaling)
    pub exponent: i8,

    /// Quantized value
    pub value: i64,
}

impl PartialEq for Quantized {
    fn eq(&self, rhs: &Self) -> bool {
        self.real_value().eq(&rhs.real_value())
    }
}

impl PartialOrd for Quantized {
    fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
        self.real_value().partial_cmp(&rhs.real_value())
    }
}

impl Eq for Quantized {}

impl Ord for Quantized {
    fn cmp(&self, rhs: &Self) -> Ordering {
        self.real_value().total_cmp(&rhs.real_value())
    }
}

impl Quantized {
    /// Determines best suited exponent to quantize given value
    pub(crate) fn find_exponent(value: f64) -> i8 {
        let mut val = value;
        let mut exponent = 0;

        while val.fract() != 0.0 {
            val *= 10.0;
            exponent += 1;
        }

        exponent
    }

    pub fn new(value: f64, exponent: i8) -> Self {
        let value = (value * 10.0_f64.powi(exponent as i32)).round() as i64;
        Self { value, exponent }
    }

    /// Quantizes given value, automatically selecting most appropriate
    /// scaling, returning a [Quantized] value.
    pub fn auto_scaled(value: f64) -> Self {
        let exponent = Self::find_exponent(value);
        Self::new(value, exponent)
    }

    /// Returns quantized value
    pub fn real_value(&self) -> f64 {
        self.value as f64 / 10.0_f64.powi(self.exponent as i32)
    }
}

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

    #[test]
    fn test_exponent_finder() {
        assert_eq!(Quantized::find_exponent(5.0), 0);
        assert_eq!(Quantized::find_exponent(5.5), 1);
        assert_eq!(Quantized::find_exponent(0.5), 1);
        assert_eq!(Quantized::find_exponent(1.25), 2);
        assert_eq!(Quantized::find_exponent(0.25), 2);
        assert_eq!(Quantized::find_exponent(0.333), 3);
    }

    #[test]
    fn test_quantized_ordering() {
        assert!(Quantized::new(1.0, 0) > Quantized::new(0.1, 0));
        assert!(Quantized::new(1.0, 0) < Quantized::new(1.1, 1));
        assert!(Quantized::new(1.0, 0) <= Quantized::new(1.1, 1));
        assert!(Quantized::new(1.12, 3) > Quantized::new(1.1, 1));
        assert!(Quantized::new(1.101, 4) > Quantized::new(1.1, 1));
        assert!(Quantized::new(-1.0, 1) < Quantized::new(0.0, 1));
    }

    #[test]
    fn test_quantization() {
        for (real_value, exponent) in [
            (1.0, 0),
            (1.0, 1),
            (1.1, 1),
            (1.25, 2),
            (1.333, 3),
            (-3.215, 3),
        ] {
            let q = Quantized::new(real_value, exponent);

            assert_eq!(
                q.real_value(),
                real_value,
                "test failed for {} 10**{}",
                real_value,
                exponent
            );
        }
    }
}