Struct HistogramFast

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

Faster version of HistogramInt for Integers

provided the bins should be: (left, left +1, …, right - 1) then you should use this version!

Implementations

impl<T> HistogramFast<T>

where T: Copy,

pub fn left(&self) -> T

Get left border, inclusive

pub fn right(&self) -> T

Get right border, inclusive

pub fn range_inclusive(&self) -> RangeInclusive<T>

Returns the range covered by the bins as a RangeInclusive<T>

impl<T> HistogramFast<T>

where T: PrimInt + HasUnsignedVersion + WrappingAdd, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned>,

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

Create a new interval

• same as Self::new_inclusive(left, right - 1) though with checks
• That makes left an inclusive and right an exclusive border

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

Create new histogram with inclusive borders

• Err if left > right
• left is inclusive border
• right is inclusive border

pub fn bin_iter(&self) -> impl Iterator<Item = T>

Iterator over all the bins

In HistogramFast is hit only when a value matches the corresponding bin exactly, which means there exists a map between bins and corresponding values that would hit them. So a bin is perfectly defined by one value. That is what we are iterating over here

This iterates over these values

Example

use sampling::histogram::HistogramFast;
 
let hist = HistogramFast::<u8>::new_inclusive(2, 5).unwrap();
let vec: Vec<u8> =  hist.bin_iter().collect();
assert_eq!(&vec, &[2, 3, 4, 5]);

pub fn bin_hits_iter(&self) -> impl Iterator<Item = (T, usize)> + '_

Iterator over all the bins

In HistogramFast is hit only when a value matches the corresponding bin exactly, which means there exists a map between bins and corresponding values that would hit them.

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

Item of Iterator

(value_corresponding_to_bin, number_of_hits)

Example

use sampling::histogram::HistogramFast;
 
let mut hist = HistogramFast::<u8>::new_inclusive(2, 5).unwrap();
hist.increment(4).unwrap();
hist.increment(5).unwrap();
hist.increment(5).unwrap();
let vec: Vec<(u8, usize)> =  hist.bin_hits_iter().collect();
assert_eq!(&vec, &[(2, 0), (3, 0), (4, 1), (5, 2)]);

pub fn equal_range(&self, other: &Self) -> bool

where T: Eq,

checks if the range of two Histograms is equal, i.e., if they have the same bin borders

pub fn try_add(&mut self, other: &Self) -> Outcome

where T: Eq,

Add other histogram to self

• will fail if the ranges are not equal, i.e., if equal_range returns false
• Otherwise the hit count of the bins of self will be increased by the corresponding hit count of other.
• other will be unchanged

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

Trait Implementations

impl<T> BinDisplay for HistogramFast<T>

where T: PrimInt + HasUnsignedVersion + Copy + Display + WrappingAdd, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned>,

type BinEntry = T

What type does the displayable BinEntry have?

fn display_bin_iter(&self) -> Box<dyn Iterator<Item = Self::BinEntry> + '_>

Iterator over all the bins

fn write_bin<W: Write>(entry: &Self::BinEntry, writer: W) -> Result<()>

For writing a bin

fn write_header<W: Write>(&self, writer: W) -> Result<()>

Writing the header of the bin

impl<T: Clone> Clone for HistogramFast<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HistogramFast<T>

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

Formats the value using the given formatter.

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

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

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

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

the created histogram

fn bin_count(&self) -> usize

How many bins the histogram contains

fn reset(&mut self)

reset the histogram to zero

fn increment_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> HistogramCombine for HistogramFast<T>

where Self: HistogramVal<T>, T: PrimInt + HasUnsignedVersion + WrappingAdd, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned>,

fn encapsulating_hist<S>(hists: &[S]) -> Result<Self, HistErrors>

where S: Borrow<Self>,

Create a histogram, which encapsulates the histograms passed

fn align<S>(&self, right: S) -> Result<usize, HistErrors>

where S: Borrow<Self>,

Get bin difference between histograms

impl<T> HistogramIntervalDistance<T> for HistogramFast<T>

where Self: HistogramVal<T>, T: PartialOrd + Sub<Output = T> + 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 HistogramFast<T>

where T: PrimInt + CheckedSub + ToPrimitive + CheckedAdd + One + FromPrimitive + HasUnsignedVersion + Bounded + WrappingAdd, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes, Unsigned = T::Unsigned> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned> + FromPrimitive + WrappingSub,

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

partition the interval

impl<T> HistogramVal<T> for HistogramFast<T>

where T: PrimInt + HasUnsignedVersion + WrappingAdd, T::Unsigned: Bounded + HasUnsignedVersion<LeBytes = T::LeBytes> + WrappingAdd + ToPrimitive + Sub<Output = T::Unsigned>,

fn bin_enum_iter(&self) -> Box<dyn Iterator<Item = Bin<T>> + '_>

Iterator over the bins

• This iterator will always return SingleValued bins
• Consider using self.bin_iter() instead, its more efficient

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 distance<V: Borrow<T>>(&self, val: V) -> f64

calculates some sort of absolute distance to the nearest valid bin

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

convert val to the respective histogram index

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 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

impl<T> IntervalOrder for HistogramFast<T>

where T: PrimInt,

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

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

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