Struct ndarray_stats::histogram::Bins

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

Bins is a sorted collection of non-overlapping 1-dimensional intervals.

All intervals are left-inclusive and right-exclusive.

Example:

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

Given a collection of Edges, it returns the corresponding Bins instance.

pub fn len(&self) -> usize

Returns the number of bins.

Example:

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 index_of(&self, value: &A) -> Option<usize>

Given value, it returns:

• Some(i), if the i-th bin in self contains value;
• None, if value does not belong to any of the bins in self.

Example:

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

let edges = Edges::from(vec![0, 2, 4, 6]);
let bins = Bins::new(edges);
let value = 1;
assert_eq!(
    bins.index_of(&1),
    Some(0)
);
assert_eq!(
    bins.index(bins.index_of(&1).unwrap()),
    0..2
);

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

Given value, it returns:

• Some(left_edge..right_edge), if there exists a bin in self such that left_edge <= value < right_edge;
• None, otherwise.

Example:

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

let edges = Edges::from(vec![0, 2, 4, 6]);
let bins = Bins::new(edges);
assert_eq!(
    bins.range_of(&1),
    Some(0..2)
);
assert_eq!(
    bins.range_of(&10),
    None
);

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

Get the i-th bin.

Panics if index is out of bounds.

Example:

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.

pub 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: Eq + Ord> Eq for Bins<A>

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

fn eq(&self, other: &Bins<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Bins<A>) -> bool

This method tests for !=.

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

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