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.

impl<A, V> HashHistogram<A, V>

pub fn par_values(&self) -> impl ParallelIterator<Item = &V>

where V: Sync,

An immutable rayon parallel iterator over the histogram values.

It only iterates over filled bins in the sparse histogram. This requires the “rayon” crate feature to be enabled.

pub fn par_values_mut(&mut self) -> impl ParallelIterator<Item = &mut V>

where V: Send,

A mutable rayon parallel iterator over the histogram values.

It only iterates over filled bins in the sparse histogram. This requires the “rayon” crate feature to be enabled.

pub fn par_iter( &self, ) -> impl ParallelIterator<Item = Item<<A as Axis>::BinInterval, &V>>

where A: Axis + Sync, V: Sync, <A as Axis>::BinInterval: Send,

An immutable rayon parallel iterator over bin indices, bin interval and bin values.

It only iterates over filled bins in the sparse histogram. This requires the “rayon” crate feature to be enabled.

pub fn par_iter_mut( &mut self, ) -> impl ParallelIterator<Item = Item<<A as Axis>::BinInterval, &mut V>>

where A: Axis + Sync + Send, V: Send + Sync, <A as Axis>::BinInterval: Send,

An mutable rayon parallel iterator over bin indices, bin interval and bin values.

It only iterates over filled bins in the sparse histogram. This requires the “rayon” crate feature to be enabled.

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 duplicate 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<'de, A, V> Deserialize<'de> for HashHistogram<A, V>

where A: Deserialize<'de>, V: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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, V> Serialize for HashHistogram<A, V>

where A: Serialize, V: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

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>