Struct net_ensembles::sampling::HistogramInt

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

Generic Histogram for integer types

Implementations

impl<T> HistogramInt<T>

pub fn borders(&self) -> &Vec<T, Global>

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: Add<T, Output = T> + Ord + One + Copy + NumCast + Sub<T, Output = T>,

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

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

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: Zero + Copy + PartialOrd<T> + ToPrimitive + FromPrimitive + CheckedAdd + One<Output = T> + HasUnsignedVersion + Bounded + Sub<T, Output = T> + Mul<T>,
    RangeInclusive<T>: Iterator<Item = T>,
    <T as HasUnsignedVersion>::Unsigned: Bounded + HasUnsignedVersion<LeBytes = <T as HasUnsignedVersion>::LeBytes, Unsigned = <T as HasUnsignedVersion>::Unsigned> + WrappingAdd + ToPrimitive + Sub<<T as HasUnsignedVersion>::Unsigned, Output = <T as HasUnsignedVersion>::Unsigned> + Rem<<T as HasUnsignedVersion>::Unsigned, Output = <T as HasUnsignedVersion>::Unsigned> + FromPrimitive + Zero + Eq + Div<<T as HasUnsignedVersion>::Unsigned, Output = <T as HasUnsignedVersion>::Unsigned> + Ord + Mul<<T as HasUnsignedVersion>::Unsigned, Output = <T as HasUnsignedVersion>::Unsigned> + WrappingSub + Copy,
    RangeInclusive<<T as HasUnsignedVersion>::Unsigned>: Iterator<Item = <T as HasUnsignedVersion>::Unsigned>,

pub fn new(left: T, right: T, bins: usize) -> Result<HistogramInt<T>, 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<HistogramInt<T>, 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 for HistogramInt<T>where
    T: Clone,

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 for HistogramInt<T>where
    T: Debug,

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

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<HistogramInt<T>, <__D as Deserializer<'de>>::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>) -> HistogramInt<T>

Converts to this type from the input type.

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

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

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

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: Sub<T, Output = T> + Add<T, Output = T> + One + NumCast + Copy + Ord,

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

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<HistogramInt<T>, Global>, HistErrors>

partition the interval

impl<T> HistogramVal<T> for HistogramInt<T>where
    T: Sub<T, Output = T> + Add<T, Output = T> + One + NumCast + Copy + Ord,

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

None if not inside Hist covered zone

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

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

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

calculates some sort of absolute distance to the nearest valid bin

fn first_border(&self) -> T

get the left most border (inclusive)

fn second_last_border(&self) -> T

get second last border from the right

should be the same as let b = self.borders_clone().expect("overflow"); assert_eq!(self.second_last_border(), b[b.len()-2])

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

does a value correspond to a valid bin?

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

opposite of is_inside

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

binning borders

impl<T> IntervalOrder for HistogramInt<T>where
    T: Ord,

fn left_compare(&self, other: &HistogramInt<T>) -> 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 as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.