Struct DataBounds 

pub struct DataBounds<X, Y>
where
    X: PartialOrd + Copy,
    Y: PartialOrd + Copy,
{
    pub min_x: X,
    pub max_x: X,
    pub min_y: Y,
    pub max_y: Y,
}

Represents the bounds of a dataset in 2D space

Fields

min_x: X

Minimum X value

max_x: X

Maximum X value

min_y: Y

Minimum Y value

max_y: Y

Maximum Y value

Implementations

impl<X, Y> DataBounds<X, Y>

where X: PartialOrd + Copy, Y: PartialOrd + Copy,

pub fn new(min_x: X, max_x: X, min_y: Y, max_y: Y) -> DataResult<Self>

Create new data bounds

pub fn width(&self) -> X

where X: Sub<Output = X>,

Get the width of the X range

pub fn height(&self) -> Y

where Y: Sub<Output = Y>,

Get the height of the Y range

pub fn contains<P>(&self, point: &P) -> bool

where P: DataPoint<X = X, Y = Y>,

Check if a point is within these bounds

pub fn expand_to_include<P>(&mut self, point: &P)

where P: DataPoint<X = X, Y = Y>,

Expand bounds to include a new point

pub fn merge(&self, other: &Self) -> Self

Merge with another bounds, creating a bounds that contains both

impl DataBounds<f32, f32>

pub fn with_padding(&self, padding_percent: f32) -> Self

Create bounds with some padding around the data

pub fn nice_bounds(&self) -> Self

Create bounds that are nice for display (rounded to nice numbers)

Trait Implementations

impl<X, Y> Clone for DataBounds<X, Y>

where X: PartialOrd + Copy + Clone, Y: PartialOrd + Copy + Clone,

fn clone(&self) -> DataBounds<X, Y>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<X, Y> Debug for DataBounds<X, Y>

where X: PartialOrd + Copy + Debug, Y: PartialOrd + Copy + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<X, Y> PartialEq for DataBounds<X, Y>

where X: PartialOrd + Copy + PartialEq, Y: PartialOrd + Copy + PartialEq,

fn eq(&self, other: &DataBounds<X, Y>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<X, Y> Copy for DataBounds<X, Y>

where X: PartialOrd + Copy + Copy, Y: PartialOrd + Copy + Copy,

impl<X, Y> StructuralPartialEq for DataBounds<X, Y>

where X: PartialOrd + Copy, Y: PartialOrd + Copy,