Struct sampling::histogram::HistogramInt

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

Generic Histogram for integer types

Implementations

impl<T> HistogramInt<T>

pub fn borders(&self) -> &Vec<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 HistogramInt 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 = HistI8::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(&self) -> impl Iterator<Item = (&[T; 2], usize)>

Iterate over all bins

In HistogramInt 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)

Item of Iterator

(&[left_border, right_border], number_of_hits)

Example

use sampling::histogram::*;
 
let mut hist = HistUsize::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> HistogramInt<T>

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

pub fn increment<V: Borrow<T>>(&mut 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 HistogramVal::count_val

pub fn increment_quiet<V: Borrow<T>>(&mut 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

impl<T> HistogramInt<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: Clone> Clone for HistogramInt<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HistogramInt<T>

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

Formats the value using the given formatter.

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

fn bin_count(&self) -> usize

How many bins the histogram contains

fn hist(&self) -> &Vec<usize>

the created histogram

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

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

fn reset(&mut self)

reset the histogram to zero

fn count_index(&mut 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> HistogramIntervalDistance<T> for HistogramInt<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 HistogramInt<T>

where T: Clone + Debug,

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

partition the interval

impl<T> HistogramVal<T> for HistogramInt<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 bin_enum_iter(&self) -> Box<dyn Iterator<Item = Bin<T>> + '_>

consider using self.bin_iter() instead

• this will return an iterater over the bins for displaying purposes
• all bins are defined via an inclusive and an exclusive border
• It is more efficient to use self.bin_iter()instead

fn count_val<V: Borrow<T>>(&mut 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 last border from the right

fn last_border_is_inclusive(&self) -> bool

True if last border is inclusive, false otherwise

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

impl<T> IntervalOrder for HistogramInt<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 HistogramInt<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.