Struct HashHistogram

pub struct HashHistogram<A, V> { /* private fields */ }

A sparse N-dimensional Histogram that stores its values in a HashMap.

Only bins that are filled will consume memory. This makes high-dimensional, many-binned (but mostly empty) histograms possible. If memory usage is not a concern, see VecHistogram.

See crate::sparsehistogram for examples of its use.

Implementations

impl<A: Axis, V> HashHistogram<A, V>

pub fn new(axes: A) -> Self

Factory method for HashHistogram. It is recommended to use the sparsehistogram macro instead.

Trait Implementations

impl<A: Axis + PartialEq + Clone, V> Add<&HashHistogram<A, V>> for &HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Default, for<'a> &'a V: Add<Output = V>,

fn add(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, returning a copy, and leaving the original histograms intact.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (&hist1 + &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &3.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the + operator.

impl<A: Axis + PartialEq + Clone, V> Add<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Clone + Default + AddAssign<&'a V>,

fn add(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, consuming the left-hand histogram and returning a new value. As this avoids making copies of the histograms, this is the recommended method to merge histograms.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (hist1 + &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &3.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the + operator.

impl<A: Axis + PartialEq, V> AddAssign<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Default + AddAssign<&'a V>,

fn add_assign(&mut self, rhs: &HashHistogram<A, V>)

Combine the right-hand histogram with the left-hand histogram, mutating the left-hand histogram.

Panics

Panics if the histograms have incompatible axes. To handle this failure mode at runtime, use the non-assign version of this operation, which returns an Result.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
hist1 += &hist2;
assert_eq!(hist1.value(&0.0).unwrap(), &3.0);

impl<A: Clone, V: Clone> Clone for HashHistogram<A, V>

fn clone(&self) -> HashHistogram<A, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, V: Debug> Debug for HashHistogram<A, V>

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

Formats the value using the given formatter.

impl<A: Default, V: Default> Default for HashHistogram<A, V>

fn default() -> HashHistogram<A, V>

Returns the “default value” for a type.

impl<A: Axis, V> Display for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Into<f64>, A::BinInterval: Display,

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

Formats the value using the given formatter.

impl<A: Axis + PartialEq + Clone, V> Div<&HashHistogram<A, V>> for &HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Default, for<'a> &'a V: Div<Output = V>,

fn div(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, returning a copy, and leaving the original histograms intact.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (&hist1 / &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &2.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the / operator.

impl<A: Axis + PartialEq + Clone, V> Div<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Clone + Default + DivAssign<&'a V>,

fn div(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, consuming the left-hand histogram and returning a new value. As this avoids making copies of the histograms, this is the recommended method to merge histograms.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (hist1 / &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &2.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the / operator.

impl<A: Axis + PartialEq, V> DivAssign<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Default + DivAssign<&'a V>,

fn div_assign(&mut self, rhs: &HashHistogram<A, V>)

Combine the right-hand histogram with the left-hand histogram, mutating the left-hand histogram.

Panics

Panics if the histograms have incompatible axes. To handle this failure mode at runtime, use the non-assign version of this operation, which returns an Result.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
hist1 /= &hist2;
assert_eq!(hist1.value(&0.0).unwrap(), &2.0);

impl<A: Axis, V: Default> Histogram<A, V> for HashHistogram<A, V>

fn axes(&self) -> &A

The histogram Axes that map coordinates to bin numbers.

fn value_at_index(&self, index: usize) -> Option<&V>

Read a bin value given an index. Return an Option as the given index may not be valid for this histogram.

fn values(&self) -> Box<dyn Iterator<Item = &'_ V> + '_>

Iterator over bin values.

fn iter( &self, ) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ V>> + '_>

Iterator over bin indices, bin interval and bin values.

fn value_at_index_mut(&mut self, index: usize) -> Option<&mut V>

Mutable access to a bin value at a given index.

fn values_mut(&mut self) -> Box<dyn Iterator<Item = &'_ mut V> + '_>

Mutable iterator over bin values.

fn iter_mut( &mut self, ) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ mut V>> + '_>

Mutable iterator over bin indices, bin interval and bin values.

fn fill(&mut self, coordinate: &A::Coordinate)

where V: Fill,

Fill the histogram bin value at coordinate with unit weight. If the Axes do not cover that coordinate, do nothing. See Fill.

fn fill_with<D>(&mut self, coordinate: &A::Coordinate, data: D)

where V: FillWith<D>,

Fill the histogram bin value at coordinate with some data. If the Axes do not cover that coordinate, do nothing. See FillWith.

fn fill_with_weighted<D, W>( &mut self, coordinate: &A::Coordinate, data: D, weight: W, )

where V: FillWithWeighted<D, W>,

Fill the histogram bin value at coordinate with some data. If the Axes do not cover that coordinate, do nothing. See FillWithWeighted.

fn value(&self, coordinate: &A::Coordinate) -> Option<&V>

Read a bin value given a coordinate. Returns an Option as the given coordinate may not be mapped to a bin.

fn value_mut(&mut self, coordinate: &A::Coordinate) -> Option<&mut V>

Mutable access to a bin value at a given coordinate.

impl<'a, A: Axis, V> IntoIterator for &'a HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>,

type Item = Item<<A as Axis>::BinInterval, &'a V>

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'a V>> + 'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A: Axis, V: 'a> IntoIterator for &'a mut HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>,

type Item = Item<<A as Axis>::BinInterval, &'a mut V>

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'a mut V>> + 'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Axis + PartialEq + Clone, V> Mul<&HashHistogram<A, V>> for &HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Default, for<'a> &'a V: Mul<Output = V>,

fn mul(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, returning a copy, and leaving the original histograms intact.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (&hist1 * &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &2.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the * operator.

impl<A: Axis + PartialEq + Clone, V> Mul<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Clone + Default + MulAssign<&'a V>,

fn mul(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, consuming the left-hand histogram and returning a new value. As this avoids making copies of the histograms, this is the recommended method to merge histograms.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (hist1 * &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &2.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the * operator.

impl<A: Axis + PartialEq, V> MulAssign<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Default + MulAssign<&'a V>,

fn mul_assign(&mut self, rhs: &HashHistogram<A, V>)

Combine the right-hand histogram with the left-hand histogram, mutating the left-hand histogram.

Panics

Panics if the histograms have incompatible axes. To handle this failure mode at runtime, use the non-assign version of this operation, which returns an Result.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
hist1 *= &hist2;
assert_eq!(hist1.value(&0.0).unwrap(), &2.0);

impl<A: PartialEq, V: PartialEq> PartialEq for HashHistogram<A, V>

fn eq(&self, other: &HashHistogram<A, V>) -> 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: Axis + PartialEq + Clone, V> Sub<&HashHistogram<A, V>> for &HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Default, for<'a> &'a V: Sub<Output = V>,

fn sub(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, returning a copy, and leaving the original histograms intact.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (&hist1 - &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &1.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the - operator.

impl<A: Axis + PartialEq + Clone, V> Sub<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Clone + Default + SubAssign<&'a V>,

fn sub(self, rhs: &HashHistogram<A, V>) -> Self::Output

Combine the right-hand histogram with the left-hand histogram, consuming the left-hand histogram and returning a new value. As this avoids making copies of the histograms, this is the recommended method to merge histograms.

If the input histograms have incompatible axes, this operation will return a crate::error::BinaryOperationError.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
let combined_hist = (hist1 - &hist2).expect("Axes are compatible");
assert_eq!(combined_hist.value(&0.0).unwrap(), &1.0);

type Output = Result<HashHistogram<A, V>, BinaryOperationError>

The resulting type after applying the - operator.

impl<A: Axis + PartialEq, V> SubAssign<&HashHistogram<A, V>> for HashHistogram<A, V>

where HashHistogram<A, V>: Histogram<A, V>, for<'a> V: Default + SubAssign<&'a V>,

fn sub_assign(&mut self, rhs: &HashHistogram<A, V>)

Combine the right-hand histogram with the left-hand histogram, mutating the left-hand histogram.

Panics

Panics if the histograms have incompatible axes. To handle this failure mode at runtime, use the non-assign version of this operation, which returns an Result.

Examples

use ndhistogram::{Histogram, sparsehistogram, axis::Uniform};
let mut hist1 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
let mut hist2 = sparsehistogram!(Uniform::<f64>::new(10, -5.0, 5.0)?);
hist1.fill_with(&0.0, 2.0);
hist2.fill(&0.0);
hist1 -= &hist2;
assert_eq!(hist1.value(&0.0).unwrap(), &1.0);

impl<A: Eq, V: Eq> Eq for HashHistogram<A, V>

impl<A, V> StructuralPartialEq for HashHistogram<A, V>