Struct ndarray_stats::histogram::Edges

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

A sorted collection of type A elements used to represent the boundaries of intervals, i.e. Bins on a 1-dimensional axis.

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

Examples

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

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

Implementations

impl<A: Ord> Edges<A>

pub fn len(&self) -> usize

Returns the number of edges in self.

Examples

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 is_empty(&self) -> bool

Returns true if self contains no edges.

Examples

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

let edges = Edges::<N64>::from(vec![]);
assert_eq!(edges.is_empty(), true);

let edges = Edges::from(vec![n64(0.), n64(2.), n64(5.)]);
assert_eq!(edges.is_empty(), false);

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

Returns an immutable 1-dimensional array view of edges.

Examples

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)>

Returns indices of two consecutive edges in self, if the interval they represent contains the given value, or returns None otherwise.

That is to say, it returns

• Some((left, right)), where left and right are the indices of two consecutive edges in self and right == left + 1, if self[left] <= value < self[right];
• None, otherwise.

Examples

use ndarray_stats::histogram::Edges;

let edges = Edges::from(vec![0, 2, 3]);
// `1` is in the interval [0, 2), whose indices are (0, 1)
assert_eq!(
    edges.indices_of(&1),
    Some((0, 1))
);
// `5` is not in any of intervals
assert_eq!(
    edges.indices_of(&5),
    None
);

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

Returns an iterator over the edges in self.

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

Converts an Array1<A> into an Edges<A>, consuming the 1-dimensional array. The array will be sorted in increasing order using an unstable sorting algorithm, with duplicates removed.

Current implementation

The current sorting algorithm is the same as std::slice::sort_unstable(), which is based on pattern-defeating quicksort.

This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate) , and O(n log n) worst-case.

Examples

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>> for Edges<A>

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

Converts a Vec<A> into an Edges<A>, consuming the edges. The vector will be sorted in increasing order using an unstable sorting algorithm, with duplicates removed.

Current implementation

The current sorting algorithm is the same as std::slice::sort_unstable(), which is based on pattern-defeating quicksort.

This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate) , and O(n log n) worst-case.

Examples

use ndarray::array;
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

Returns a reference to the i-th edge in self.

Panics

Panics if the index i is out of bounds.

Examples

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 for Edges<A>

fn eq(&self, other: &Edges<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 Edges<A>

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