Struct Edges

pub struct Edges<A: Ord + Send> { /* 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_histogram::{
	histogram::{Bins, Edges},
	o64,
};

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

Implementations

impl<A: Ord + Send> Edges<A>

pub fn len(&self) -> usize

Returns the number of edges in self.

Examples

use ndarray_histogram::{histogram::Edges, o64};

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

pub fn is_empty(&self) -> bool

Returns true if self contains no edges.

Examples

use ndarray_histogram::{O64, histogram::Edges, o64};

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

let edges = Edges::from(vec![o64(0.), o64(2.), o64(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_histogram::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] it returns

• None,

else otherwise.

Examples

use ndarray_histogram::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 + Send> Clone for Edges<A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Ord + Send> Debug for Edges<A>

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

Formats the value using the given formatter.

impl<A: Ord + Send + 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_histogram::histogram::Edges;

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

impl<A: Ord + Send> 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_histogram::histogram::Edges;

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

impl<A: Ord + Send> 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_histogram::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 + Send> 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 + Send> Eq for Edges<A>

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