lognplot 0.1.0

Log and plot data
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::axis_options::AxisOptions;
use crate::geometry::Range;
use crate::time::{TimeSpan, TimeStamp};

#[derive(Default, Clone)]
pub struct Axis {
    pub options: AxisOptions,
    pub label: Option<String>,
    range: Range<f64>,
}

impl Axis {
    pub fn set_limits(&mut self, begin: f64, end: f64) {
        self.range.set_begin(begin);
        self.range.set_end(end);
    }

    pub fn begin(&self) -> f64 {
        self.range.begin()
    }

    pub fn end(&self) -> f64 {
        self.range.end()
    }

    /// Get the time selected by this axis!
    pub fn timespan(&self) -> TimeSpan {
        // TODO: temp hack?
        TimeSpan::new(TimeStamp::new(self.begin()), TimeStamp::new(self.end()))
    }

    pub fn domain(&self) -> f64 {
        self.end() - self.begin()
    }

    /// Given the current axis, calculate sensible
    /// tick spacing.
    fn calc_tick_spacing(&self, n_ticks: usize) -> f64 {
        let domain: f64 = self.domain();
        let scale = domain.log10().floor();
        let approx = (10.0_f64).powf(-scale) * domain / (n_ticks as f64);

        // Snap to grid:
        // 10, 20, 25, 50
        let options = vec![0.1, 0.2, 0.5, 1.0, 2.0, 5.0];
        let best = options
            .iter()
            .min_by_key(|x| (((*x - approx).abs() * 1_000_000.0) as i64))
            .unwrap();

        trace!(
            "domain: {}, Scale {}, approx: {}, best: {}",
            domain,
            scale,
            approx,
            best
        );

        let tick_width = best * (10.0_f64).powf(scale);
        tick_width
    }

    /// Calculate the proper major tick and minor ticks for
    /// a given range.
    pub fn calc_tiks(&self, n_ticks: usize) -> Vec<(f64, String)> {
        trace!("Calculating ticks!");
        // let n_ticks = 7; // Always nice to have 7 ticks!
        let tick_step = self.calc_tick_spacing(n_ticks);
        trace!("tickz {:?}", tick_step);

        let mut x = ceil_to_multiple_of(self.range.begin(), tick_step);
        let mut res = vec![];

        while x < self.range.end() {
            let label = x.to_string();
            res.push((x, label));
            x += tick_step;
        }

        trace!("Ticks: {:?}", res);
        res
    }
}

/// Round the given number to an integer multiple of the given step size.
fn ceil_to_multiple_of(x: f64, step: f64) -> f64 {
    let offset = x % step;
    if offset > 0.0 {
        x + step - offset
    } else if offset < 0.0 {
        x - offset
    } else {
        x
    }
}

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

    #[test]
    fn tick_calculation() {
        // Set axis to 12 to 87 and expect ticks at 20, 30, 40, 50, 60, 70 and 80.
        let mut axis = Axis::default();
        axis.set_limits(12.0, 87.0);
        let ticks = axis.calc_tiks(7);

        assert_eq!(
            vec![
                // (10.0, "10".to_string()),
                (20.0, "20".to_string()),
                (30.0, "30".to_string()),
                (40.0, "40".to_string()),
                (50.0, "50".to_string()),
                (60.0, "60".to_string()),
                (70.0, "70".to_string()),
                (80.0, "80".to_string()),
            ],
            ticks
        );
    }

    #[test]
    fn tick_calculation_negative() {
        // Set axis to -44 to 46 and expect ticks at -40, -30, -20, -10, 0, 10, 20, 30 and 40.
        let mut axis = Axis::default();
        axis.set_limits(-44.0, 46.0);
        let ticks = axis.calc_tiks(7);

        assert_eq!(
            vec![
                (-40.0, "-40".to_string()),
                (-30.0, "-30".to_string()),
                (-20.0, "-20".to_string()),
                (-10.0, "-10".to_string()),
                (0.0, "0".to_string()),
                (10.0, "10".to_string()),
                (20.0, "20".to_string()),
                (30.0, "30".to_string()),
                (40.0, "40".to_string()),
            ],
            ticks
        );
    }
}