Struct ndarray_stats::histogram::Bins

pub struct Bins<A: Ord> { /* private fields */ }

A sorted collection of non-overlapping 1-dimensional intervals.

Note that all intervals are left-closed and right-open.

Examples

use ndarray_stats::histogram::{Edges, Bins};
use noisy_float::types::n64;

let edges = Edges::from(vec![n64(0.), n64(1.), n64(2.)]);
let bins = Bins::new(edges);
// first bin
assert_eq!(
    bins.index(0),
    n64(0.)..n64(1.) // n64(1.) is not included in the bin!
);
// second bin
assert_eq!(
    bins.index(1),
    n64(1.)..n64(2.)
);

Implementations

impl<A: Ord> Bins<A>

pub fn new(edges: Edges<A>) -> Self

Returns a Bins instance where each bin corresponds to two consecutive members of the given Edges, consuming the edges.

pub fn len(&self) -> usize

Returns the number of bins in self.

Examples

use ndarray_stats::histogram::{Edges, Bins};
use noisy_float::types::n64;

let edges = Edges::from(vec![n64(0.), n64(1.), n64(2.)]);
let bins = Bins::new(edges);
assert_eq!(
    bins.len(),
    2
);

pub fn is_empty(&self) -> bool

Returns true if the number of bins is zero, i.e. if the number of edges is 0 or 1.

Examples

use ndarray_stats::histogram::{Edges, Bins};
use noisy_float::types::{N64, n64};

// At least 2 edges is needed to represent 1 interval
let edges = Edges::from(vec![n64(0.), n64(1.), n64(3.)]);
let bins = Bins::new(edges);
assert_eq!(bins.is_empty(), false);

// No valid interval == Empty
let edges = Edges::<N64>::from(vec![]);
let bins = Bins::new(edges);
assert_eq!(bins.is_empty(), true);
let edges = Edges::from(vec![n64(0.)]);
let bins = Bins::new(edges);
assert_eq!(bins.is_empty(), true);

pub fn index_of(&self, value: &A) -> Option<usize>

Returns the index of the bin in self that contains the given value, or returns None if value does not belong to any bins in self.

Examples

Basic usage:

use ndarray_stats::histogram::{Edges, Bins};

let edges = Edges::from(vec![0, 2, 4, 6]);
let bins = Bins::new(edges);
let value = 1;
// The first bin [0, 2) contains `1`
assert_eq!(
    bins.index_of(&1),
    Some(0)
);
// No bin contains 100
assert_eq!(
    bins.index_of(&100),
    None
)

Chaining Bins::index and Bins::index_of to get the boundaries of the bin containing the value:

assert_eq!(
    // using `Option::map` to avoid panic on index out-of-bounds
    bins.index_of(&1).map(|i| bins.index(i)),
    Some(0..2)
);

pub fn range_of(&self, value: &A) -> Option<Range<A>>

where A: Clone,

Returns a range as the bin which contains the given value, or returns None otherwise.

Examples

use ndarray_stats::histogram::{Edges, Bins};

let edges = Edges::from(vec![0, 2, 4, 6]);
let bins = Bins::new(edges);
// [0, 2) contains `1`
assert_eq!(
    bins.range_of(&1),
    Some(0..2)
);
// `10` is not in any interval
assert_eq!(
    bins.range_of(&10),
    None
);

pub fn index(&self, index: usize) -> Range<A>

where A: Clone,

Returns a range as the bin at the given index position.

Panics

Panics if index is out of bounds.

Examples

use ndarray_stats::histogram::{Edges, Bins};

let edges = Edges::from(vec![1, 5, 10, 20]);
let bins = Bins::new(edges);
assert_eq!(
    bins.index(1),
    5..10
);

Trait Implementations

impl<A: Clone + Ord> Clone for Bins<A>

fn clone(&self) -> Bins<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Ord> Debug for Bins<A>

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

Formats the value using the given formatter.

impl<A: PartialEq + Ord> PartialEq for Bins<A>

fn eq(&self, other: &Bins<A>) -> 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<A: Eq + Ord> Eq for Bins<A>

impl<A: Ord> StructuralPartialEq for Bins<A>