Struct sampling::histogram::HistogramFloat

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

Generic Histogram struct

Implementations

impl<T> HistogramFloat<T>

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

similar to self.borders_clone but does not allocate memory

impl<T> HistogramFloat<T>where
    T: Float + PartialOrd + FromPrimitive,

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

Create a new Historgram

• right exclusive, left inclusive
• if you want right to behave (almost) the same as an inclusive border, consider using new(left, right + T::EPSILON, bins) (make sure, that adding Epsilon actually changes the value!)

pub fn interval_length(&self) -> T

Returns the length of the interval

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

Iterator over all the bins

In HistogramFloat 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 = HistogramFloat::<f32>::new(0.0, 1.0, 2).unwrap();
let mut iter = hist.bin_iter();
assert_eq!(iter.next(), Some(&[0.0, 0.5]));
assert_eq!(iter.next(), Some(&[0.5, 1.0]));
assert_eq!(iter.next(), None);

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

Iterate over all bins

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

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

Item of Iterator

(&[left_border, right_border], number_of_hits)

Example

use sampling::histogram::*;
 
let mut hist = HistogramFloat::<f64>::new(0.0, 1.0, 2).unwrap();
 
hist.increment_quiet(0.5);
hist.increment_quiet(0.71253782387);
 
let mut iter = hist.bin_hits_iter();
assert_eq!(iter.next(), Some((&[0.0, 0.5], 0)));
assert_eq!(iter.next(), Some((&[0.5, 1.0], 2)));
assert_eq!(iter.next(), None);

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

Increment hit count of bin

This will increment the hit count of the bin corresponding to the value val. If the bin was valid it will return the index of the corresponding bin

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HistogramFloat<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for HistogramFloat<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<AtomicHistogramFloat<T>> for HistogramFloat<T>

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

Converts to this type from the input type.

impl<T> From<HistogramFloat<T>> for AtomicHistogramFloat<T>

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

Converts to this type from the input type.

impl<T> Histogram for HistogramFloat<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 HistogramFloat<T>where
    T: Float + FromPrimitive + Zero + NumCast,

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> HistogramVal<T> for HistogramFloat<T>where
    T: Float + Zero + NumCast,

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

consider using self.borders()

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 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: 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 get_bin_index<V: Borrow<T>>(&self, val: V) -> Result<usize, HistErrors>

convert val to the respective histogram index

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