Struct sampling::histogram::AtomicHistogramInt

pub struct AtomicHistogramInt<T> { /* private fields */ }

Generic Histogram for integer types

Implementations

impl<T> AtomicHistogramInt<T>

pub fn borders(&self) -> &[T]

similar to self.borders_clone but does not allocate memory

pub fn bin_iter(&self) -> impl Iterator<Item = &[T; 2]>

Iterator over all the bins

In AtomicHistogramInt a bin is defined by two values: The left border (inclusive) and the right border (exclusive)

Here you get an iterator which iterates over said borders. The Iterator returns a borrowed Array of length two, where the first value is the left (inclusive) border and the second value is the right (exclusive) border

Example

use sampling::histogram::*;
 
let hist = AtomicHistI8::new(0, 8, 4).unwrap();
let mut bin_iter = hist.bin_iter();

assert_eq!(bin_iter.next(), Some(&[0_i8, 2]));
assert_eq!(bin_iter.next(), Some(&[2, 4]));
assert_eq!(bin_iter.next(), Some(&[4, 6]));
assert_eq!(bin_iter.next(), Some(&[6, 8]));
assert_eq!(bin_iter.next(), None);

pub fn bin_hits_iter(&mut self) -> impl Iterator<Item = (&[T; 2], usize)>

Iterate over all bins

In AtomicHistogramInt a bin is defined by two values: The left border (inclusive) and the right border (exclusive)

This iterates over these values as well as the corresponding hit count (i.e. how often the corresponding bin was hit)

Note

Since I am using atomics here it is possible that the hit-count changes during the iteration, if another thread writes to the histogram for example.

Item of Iterator

(&[left_border, right_border], number_of_hits)

Example

use sampling::histogram::*;
 
let mut hist = AtomicHistUsize::new(0, 6, 3).unwrap();
 
hist.increment(0).unwrap();
hist.increment(5).unwrap();
hist.increment(4).unwrap();
 
let mut iter = hist.bin_hits_iter();
assert_eq!(
    iter.next(),
    Some(
        (&[0, 2], 1)
    )
);
assert_eq!(
    iter.next(),
    Some(
        (&[2, 4], 0)
    )
);
assert_eq!(
    iter.next(),
    Some(
        (&[4, 6], 2)
    )
);
assert_eq!(iter.next(), None);

impl<T> AtomicHistogramInt<T>

where T: Sub<T, Output = T> + Add<T, Output = T> + Ord + One + Copy + NumCast,

pub fn increment<V: Borrow<T>>(&self, val: V) -> Result<usize, HistErrors>

Increment hit count

If val is inside the histogram, the corresponding bin count will be increased by 1 and the index corresponding to the bin in returned: Ok(index). Otherwise an Error is returned

Note

• This is the same as AtomicHistogramVal::count_val
• Uses atomic operations, so this is thread safe

pub fn increment_quiet<V: Borrow<T>>(&self, val: V)

Increment hit count

Increments the hit count of the bin corresponding to val. If no bin corresponding to val exists, nothing happens

Note

• Uses atomic operations for the counters, so this is thread safe

impl<T> AtomicHistogramInt<T>

where T: PartialOrd + ToPrimitive + FromPrimitive + CheckedAdd + One + HasUnsignedVersion + Bounded + Sub<T, Output = T> + Mul<T, Output = T> + Zero + Copy, RangeInclusive<T>: Iterator<Item = T>, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes, Unsigned = T::Unsigned> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned> + Rem<Output = T::Unsigned> + FromPrimitive + Zero + Eq + Div<Output = T::Unsigned> + Ord + Mul<Output = T::Unsigned> + WrappingSub + Copy, RangeInclusive<T::Unsigned>: Iterator<Item = T::Unsigned>,

pub fn new(left: T, right: T, bins: usize) -> Result<Self, HistErrors>

Create a new histogram

• right: exclusive border
• left: inclusive border
• bins: how many bins do you need?

Note

• (right - left) % bins == 0 has to be true, otherwise the bins cannot all have the same length!

pub fn new_inclusive(left: T, right: T, bins: usize) -> Result<Self, HistErrors>

Create a new histogram

• equivalent to Self::new(left, right + 1, bins) (except that this method checks for possible overflow)

Note:

• Due to implementation details, right cannot be T::MAX - if you try, you will get Err(HistErrors::Overflow)

Trait Implementations

impl<T> AtomicHistogram for AtomicHistogramInt<T>

fn count_multiple_index( &self, index: usize, count: usize ) -> Result<(), HistErrors>

Uses SeqCst

fn bin_count(&self) -> usize

How many bins the histogram contains

fn hist(&self) -> &[AtomicUsize]

the created histogram

fn reset(&mut self)

reset the histogram to zero

fn count_index(&self, index: usize) -> Result<(), HistErrors>

self.hist[index] += 1, Err() if index out of bounds

fn any_bin_zero(&self) -> bool

check if any bin was not hit yet

impl<T> AtomicHistogramVal<T> for AtomicHistogramInt<T>

where T: Ord + Sub<T, Output = T> + Add<T, Output = T> + One + NumCast + Copy,

fn get_bin_index<V: Borrow<T>>(&self, val: V) -> Result<usize, HistErrors>

None if not inside Hist covered zone

fn count_val<V: Borrow<T>>(&self, val: V) -> Result<usize, HistErrors>

count val. Ok(index), if inside of hist, Err(_) if val is invalid

fn distance<V: Borrow<T>>(&self, val: V) -> f64

calculates some sort of absolute distance to the nearest valid bin

fn first_border(&self) -> T

get the left most border (inclusive)

fn last_border(&self) -> T

Get border on the right

fn is_inside<V: Borrow<T>>(&self, val: V) -> bool

does a value correspond to a valid bin?

fn not_inside<V: Borrow<T>>(&self, val: V) -> bool

opposite of is_inside

fn borders_clone(&self) -> Result<Vec<T>, HistErrors>

binning borders

impl<T: Debug> Debug for AtomicHistogramInt<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for AtomicHistogramInt<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> From<AtomicHistogramInt<T>> for HistogramInt<T>

fn from(other: AtomicHistogramInt<T>) -> Self

Converts to this type from the input type.

impl<T> From<HistogramInt<T>> for AtomicHistogramInt<T>

fn from(other: HistogramInt<T>) -> Self

Converts to this type from the input type.

impl<T> HistogramIntervalDistance<T> for AtomicHistogramInt<T>

where T: Ord + Sub<T, Output = T> + Add<T, Output = T> + One + NumCast + Copy,

fn interval_distance_overlap<V: Borrow<T>>( &self, val: V, overlap: NonZeroUsize ) -> usize

Distance metric for how far a value is from a valid interval

impl<T> HistogramPartition for AtomicHistogramInt<T>

where T: Clone + Debug,

fn overlapping_partition( &self, n: usize, overlap: usize ) -> Result<Vec<Self>, HistErrors>

partition the interval

impl<T> IntervalOrder for AtomicHistogramInt<T>

where T: Ord,

fn left_compare(&self, other: &Self) -> Ordering

Will compare leftest bin first. if they are equal: will compare right bin

impl<T> Serialize for AtomicHistogramInt<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.