Struct ndarray_stats::histogram::Edges

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

Edges is a sorted collection of A elements used to represent the boundaries of intervals (Bins) on a 1-dimensional axis.

Example:

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

let unit_edges = Edges::from(vec![n64(0.), n64(1.)]);
let unit_interval = Bins::new(unit_edges);
// left inclusive
assert_eq!(
    unit_interval.range_of(&n64(0.)).unwrap(),
    n64(0.)..n64(1.),
);
// right exclusive
assert_eq!(
    unit_interval.range_of(&n64(1.)),
    None
);

Implementations

impl<A: Ord> Edges<A>

pub fn len(&self) -> usize

Number of edges in self.

Example:

extern crate ndarray_stats;
extern crate noisy_float;
use ndarray_stats::histogram::Edges;
use noisy_float::types::n64;

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

pub fn as_array_view(&self) -> ArrayView1<'_, A>

Borrow an immutable reference to the edges as a 1-dimensional array view.

Example:

extern crate ndarray;
extern crate ndarray_stats;
use ndarray::array;
use ndarray_stats::histogram::Edges;

let edges = Edges::from(vec![0, 5, 3]);
assert_eq!(
    edges.as_array_view(),
    array![0, 3, 5].view()
);

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

Given value, it returns an option:

• Some((left, right)), where right=left+1, if there are two consecutive edges in self such that self[left] <= value < self[right];
• None, otherwise.

Example:

extern crate ndarray_stats;
use ndarray_stats::histogram::Edges;

let edges = Edges::from(vec![0, 2, 3]);
assert_eq!(
    edges.indices_of(&1),
    Some((0, 1))
);
assert_eq!(
    edges.indices_of(&5),
    None
);

pub fn iter(&self) -> impl Iterator<Item = &A>

Trait Implementations

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

fn clone(&self) -> Edges<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 Edges<A>

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

Formats the value using the given formatter.

impl<A: Ord + Clone> From<ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>> for Edges<A>

fn from(edges: Array1<A>) -> Self

Get an Edges instance from a Array1<A>: the array elements will be sorted in increasing order using an unstable sorting algorithm and duplicates will be removed.

Example:

extern crate ndarray_stats;
use ndarray_stats::histogram::Edges;

let edges = Edges::from(vec![1, 15, 10, 20]);
// The vec gets sorted!
assert_eq!(
    edges[1],
    10
);

impl<A: Ord> From<Vec<A, Global>> for Edges<A>

fn from(edges: Vec<A>) -> Self

Get an Edges instance from a Vec<A>: the vector will be sorted in increasing order using an unstable sorting algorithm and duplicates will be removed.

Example:

extern crate ndarray_stats;
#[macro_use(array)]
extern crate ndarray;
use ndarray_stats::histogram::Edges;

let edges = Edges::from(array![1, 15, 10, 10, 20]);
// The array gets sorted!
assert_eq!(
    edges[2],
    15
);

impl<A: Ord> Index<usize> for Edges<A>

fn index(&self, i: usize) -> &Self::Output

Get the i-th edge.

Panics if the index i is out of bounds.

Example:

extern crate ndarray_stats;
use ndarray_stats::histogram::Edges;

let edges = Edges::from(vec![1, 5, 10, 20]);
assert_eq!(
    edges[1],
    5
);

type Output = A

The returned type after indexing.

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

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

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

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

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

impl<A: Eq + Ord> Eq for Edges<A>

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

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