Struct Uniform

pub struct Uniform<T = f64> { /* private fields */ }

An axis with equal sized bins.

An axis with N equally spaced, equal sized, bins between [low, high). Below (above) this range is an underflow (overflow) bin. Hence this axis has N+2 bins.

For floating point types, positive and negative infinities map to overflow and underflow bins respectively. NaN maps to the overflow bin.

Example

Create a 1D histogram with 10 uniform bins between -5.0 and 5.0, plus overflow and underflow bins.

   use ndhistogram::{ndhistogram, Histogram};
   use ndhistogram::axis::{Axis, Uniform, BinInterval};
   let hist = ndhistogram!(Uniform::new(10, -5.0, 5.0)?);
   let axis = &hist.axes().as_tuple().0;
   assert_eq!(axis.bin(0), Some(BinInterval::underflow(-5.0)));
   assert_eq!(axis.bin(1), Some(BinInterval::new(-5.0, -4.0)));
   assert_eq!(axis.bin(11), Some(BinInterval::overflow(5.0)));

Implementations

impl<T> Uniform<T>

where T: PartialOrd + Num + NumCast + NumOps + Copy,

pub fn new(num: usize, low: T, high: T) -> Result<Self, AxisError>

where T: Float,

Factory method to create an axis with num uniformly spaced bins in the range [low, high). Under/overflow bins cover values outside this range.

Only implemented for Float. Use Uniform::with_step_size for integers.

pub fn with_step_size(num: usize, low: T, step: T) -> Result<Self, AxisError>

Factory method to create an axis with num uniformly spaced bins in the range [low, low+num*step). Under/overflow bins cover values outside this range.

The number of bins and step size must both be greater than zero, otherwise an error is returned. The number of bins must be representable in the type T, otherwise an error is returned.

impl<T> Uniform<T>

pub fn low(&self) -> &T

Low edge of axis (excluding underflow bin).

pub fn high(&self) -> &T

High edge of axis (excluding overflow bin).

Trait Implementations

impl<T: PartialOrd + NumCast + NumOps + Copy> Axis for Uniform<T>

type Coordinate = T

The type representing a location on this axis.

type BinInterval = BinInterval<T>

The type of an interval representing the set of Coordinates that correspond to a histogram bin

fn index(&self, coordinate: &Self::Coordinate) -> Option<usize>

Map from coordinate to bin number. Returns an option as not all valid coordinates are necessarily contained within a bin.

fn num_bins(&self) -> usize

The number of bins in this axis, including underflow and overflow.

fn bin(&self, index: usize) -> Option<<Self as Axis>::BinInterval>

Map from bin number to axis to the interval covering the range of coordinates that this bin contains. Returns an option in case an index >= Axis::num_bins is given.

fn indices(&self) -> Box<dyn Iterator<Item = usize>>

An iterator over bin numbers

fn iter(&self) -> Box<dyn Iterator<Item = (usize, Self::BinInterval)> + '_>

An iterator over bin numbers and bin intervals

fn bins(&self) -> Box<dyn Iterator<Item = Self::BinInterval> + '_>

An iterator over bin intervals.

fn num_dim(&self) -> usize

The number of dimensions that this object corresponds to. For most Axis types this will simply be 1. However, Axes (i.e. a set of Axis) also implement Axis and should return the number of Axis that it contains.

impl<T: Clone> Clone for Uniform<T>

fn clone(&self) -> Uniform<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Uniform<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Uniform<T>

fn default() -> Uniform<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Uniform<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display> Display for Uniform<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Uniform<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T> IntoIterator for &'a Uniform<T>

where Uniform<T>: Axis,

type Item = (usize, <Uniform<T> as Axis>::BinInterval)

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = <&'a Uniform<T> as IntoIterator>::Item> + 'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for Uniform<T>

fn cmp(&self, other: &Uniform<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Uniform<T>

fn eq(&self, other: &Uniform<T>) -> 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<T: PartialOrd> PartialOrd for Uniform<T>

fn partial_cmp(&self, other: &Uniform<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Serialize for Uniform<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Uniform<T>

impl<T> StructuralPartialEq for Uniform<T>