Method set_bounds

src/plot/plot.rs:908–971

Override the default plot bounds: x axis goes from bounds.lo.x to bounds.up.x. Beware! The tick period is automatically adjusted. Changing the tick period before setting the bounds will not have the intended effect. The bounds must be set before the ticks. # Panics Panics if `lo.x >= up.x` or `lo.y >= up.y`.

(&mut self, lo: Vec2, up: Vec2)

    ///
    /// Panics if `lo.x >= up.x` or `lo.y >= up.y`.
    pub fn set_bounds(&mut self, lo: Vec2, up: Vec2) {
        if lo.x >= up.x {
            panic!("when using plot.set_bounds(), lo.x must be strictly less than up.x");
        } else if lo.y >= up.y {
            panic!("when using plot.set_bounds(), lo.y must be strictly less than up.y");
        };

        self.bounds = PlotCanvasBounds { lo, up };

        let delta = up - lo;
        let exact_tick = delta / 10.0;

        // find order of magnitude of dx
        let order_x = exact_tick.x.log10().floor();
        let mag_x = 10_f32.powf(order_x);

        let p1x = mag_x * 1.0;
        let p2x = mag_x * 2.0;
        let p5x = mag_x * 5.0;

        let psx = [p1x, p2x, p5x];

        let vx = vec![
            (p1x - exact_tick.x).abs(),
            (p2x - exact_tick.x).abs(),
            (p5x - exact_tick.x).abs(),
        ];

        use std::cmp::Ordering;
        let min_x_index = vx
            .iter()
            .enumerate()
            .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Equal))
            .map(|(index, _)| index);

        let tick_x = psx[min_x_index.unwrap()];

        let order_y = exact_tick.y.log10().floor();
        let mag_y = 10_f32.powf(order_y);

        let p1y = mag_y * 1.0;
        let p2y = mag_y * 2.0;
        let p5y = mag_y * 5.0;

        let psy = [p1y, p2y, p5y];

        let vy = vec![
            (p1y - exact_tick.y).abs(),
            (p2y - exact_tick.y).abs(),
            (p5y - exact_tick.y).abs(),
        ];

        let min_y_index = vy
            .iter()
            .enumerate()
            .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Equal))
            .map(|(index, _)| index);