Struct ndhistogram::HashHistogram
source · pub struct HashHistogram<A, V> { /* private fields */ }
Expand description
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§
source§impl<A: Axis, V> HashHistogram<A, V>
impl<A: Axis, V> HashHistogram<A, V>
sourcepub fn new(axes: A) -> Self
pub fn new(axes: A) -> Self
Factory method for HashHistogram. It is recommended to use the sparsehistogram macro instead.
source§impl<A, V> HashHistogram<A, V>
impl<A, V> HashHistogram<A, V>
sourcepub fn par_values(&self) -> impl ParallelIterator<Item = &V>where
V: Sync,
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.
sourcepub fn par_values_mut(&mut self) -> impl ParallelIterator<Item = &mut V>where
V: Send,
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.
sourcepub fn par_iter(
&self
) -> impl ParallelIterator<Item = Item<<A as Axis>::BinInterval, &V>>where
A: Axis + Sync,
V: Sync,
<A as Axis>::BinInterval: Send,
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.
sourcepub 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,
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§
source§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>,
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>,
source§fn add(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
+
operator.source§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>,
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>,
source§fn add(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
+
operator.source§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>,
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>,
source§fn add_assign(&mut self, rhs: &HashHistogram<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);
source§impl<A: Clone, V: Clone> Clone for HashHistogram<A, V>
impl<A: Clone, V: Clone> Clone for HashHistogram<A, V>
source§fn clone(&self) -> HashHistogram<A, V>
fn clone(&self) -> HashHistogram<A, V>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<A: Default, V: Default> Default for HashHistogram<A, V>
impl<A: Default, V: Default> Default for HashHistogram<A, V>
source§fn default() -> HashHistogram<A, V>
fn default() -> HashHistogram<A, V>
source§impl<'de, A, V> Deserialize<'de> for HashHistogram<A, V>where
A: Deserialize<'de>,
V: Deserialize<'de>,
impl<'de, A, V> Deserialize<'de> for HashHistogram<A, V>where A: Deserialize<'de>, V: Deserialize<'de>,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,
source§impl<A: Axis, V> Display for HashHistogram<A, V>where
HashHistogram<A, V>: Histogram<A, V>,
V: Clone + Into<f64>,
A::BinInterval: Display,
impl<A: Axis, V> Display for HashHistogram<A, V>where HashHistogram<A, V>: Histogram<A, V>, V: Clone + Into<f64>, A::BinInterval: Display,
source§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>,
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>,
source§fn div(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
/
operator.source§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>,
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>,
source§fn div(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
/
operator.source§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>,
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>,
source§fn div_assign(&mut self, rhs: &HashHistogram<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);
source§impl<A: Axis, V: Default> Histogram<A, V> for HashHistogram<A, V>
impl<A: Axis, V: Default> Histogram<A, V> for HashHistogram<A, V>
source§fn value_at_index(&self, index: usize) -> Option<&V>
fn value_at_index(&self, index: usize) -> Option<&V>
source§fn iter(
&self
) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ V>> + '_>
fn iter( &self ) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ V>> + '_>
source§fn value_at_index_mut(&mut self, index: usize) -> Option<&mut V>
fn value_at_index_mut(&mut self, index: usize) -> Option<&mut V>
source§fn values_mut(&mut self) -> Box<dyn Iterator<Item = &'_ mut V> + '_>
fn values_mut(&mut self) -> Box<dyn Iterator<Item = &'_ mut V> + '_>
source§fn iter_mut(
&mut self
) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ mut V>> + '_>
fn iter_mut( &mut self ) -> Box<dyn Iterator<Item = Item<<A as Axis>::BinInterval, &'_ mut V>> + '_>
source§fn fill(&mut self, coordinate: &A::Coordinate)where
V: Fill,
fn fill(&mut self, coordinate: &A::Coordinate)where V: Fill,
source§fn fill_with<D>(&mut self, coordinate: &A::Coordinate, data: D)where
V: FillWith<D>,
fn fill_with<D>(&mut self, coordinate: &A::Coordinate, data: D)where V: FillWith<D>,
source§fn fill_with_weighted<D, W>(
&mut self,
coordinate: &A::Coordinate,
data: D,
weight: W
)where
V: FillWithWeighted<D, W>,
fn fill_with_weighted<D, W>( &mut self, coordinate: &A::Coordinate, data: D, weight: W )where V: FillWithWeighted<D, W>,
source§impl<'a, A: Axis, V> IntoIterator for &'a HashHistogram<A, V>where
HashHistogram<A, V>: Histogram<A, V>,
impl<'a, A: Axis, V> IntoIterator for &'a HashHistogram<A, V>where HashHistogram<A, V>: Histogram<A, V>,
source§impl<'a, A: Axis, V: 'a> IntoIterator for &'a mut HashHistogram<A, V>where
HashHistogram<A, V>: Histogram<A, V>,
impl<'a, A: Axis, V: 'a> IntoIterator for &'a mut HashHistogram<A, V>where HashHistogram<A, V>: Histogram<A, V>,
source§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>,
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>,
source§fn mul(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
*
operator.source§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>,
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>,
source§fn mul(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
*
operator.source§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>,
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>,
source§fn mul_assign(&mut self, rhs: &HashHistogram<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);
source§impl<A: PartialEq, V: PartialEq> PartialEq<HashHistogram<A, V>> for HashHistogram<A, V>
impl<A: PartialEq, V: PartialEq> PartialEq<HashHistogram<A, V>> for HashHistogram<A, V>
source§fn eq(&self, other: &HashHistogram<A, V>) -> bool
fn eq(&self, other: &HashHistogram<A, V>) -> bool
self
and other
values to be equal, and is used
by ==
.source§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>,
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>,
source§fn sub(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
-
operator.source§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>,
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>,
source§fn sub(self, rhs: &HashHistogram<A, V>) -> Self::Output
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 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>
type Output = Result<HashHistogram<A, V>, BinaryOperationError>
-
operator.source§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>,
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>,
source§fn sub_assign(&mut self, rhs: &HashHistogram<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);