Struct net_ensembles::sampling::HistogramFast

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

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: CheckedSub + ToPrimitive + CheckedAdd + One + FromPrimitive + HasUnsignedVersion + PrimInt,
    <T as HasUnsignedVersion>::Unsigned: Bounded,
    <T as HasUnsignedVersion>::Unsigned: HasUnsignedVersion,
    <T as HasUnsignedVersion>::Unsigned: WrappingAdd,
    <T as HasUnsignedVersion>::Unsigned: ToPrimitive,
    <T as HasUnsignedVersion>::Unsigned: Sub<<T as HasUnsignedVersion>::Unsigned>,
    <<T as HasUnsignedVersion>::Unsigned as HasUnsignedVersion>::LeBytes == <T as HasUnsignedVersion>::LeBytes,
    <<T as HasUnsignedVersion>::Unsigned as Sub<<T as HasUnsignedVersion>::Unsigned>>::Output == <T as HasUnsignedVersion>::Unsigned, 

pub fn new(left: T, right: T) -> Result<HistogramFast<T>, 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<HistogramFast<T>, HistErrors>

Create new histogram with inclusive borders

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

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for HistogramFast<T> where
    T: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<HistogramFast<T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Histogram for HistogramFast<T>

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

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

pub fn hist(&self) -> &Vec<usize, Global>

the created histogram

pub fn bin_count(&self) -> usize

How many bins the histogram contains

pub 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> HistogramCombine for HistogramFast<T> where
    T: PartialOrd<T> + Copy + PrimInt + CheckedSub + ToPrimitive + CheckedAdd + One + FromPrimitive + HasUnsignedVersion,
    <T as HasUnsignedVersion>::Unsigned: Bounded,
    <T as HasUnsignedVersion>::Unsigned: HasUnsignedVersion,
    <T as HasUnsignedVersion>::Unsigned: WrappingAdd,
    <T as HasUnsignedVersion>::Unsigned: ToPrimitive,
    <T as HasUnsignedVersion>::Unsigned: Sub<<T as HasUnsignedVersion>::Unsigned>,
    HistogramFast<T>: HistogramVal<T>,
    <<T as HasUnsignedVersion>::Unsigned as HasUnsignedVersion>::LeBytes == <T as HasUnsignedVersion>::LeBytes,
    <<T as HasUnsignedVersion>::Unsigned as Sub<<T as HasUnsignedVersion>::Unsigned>>::Output == <T as HasUnsignedVersion>::Unsigned, 

pub fn encapsulating_hist<S>(
    hists: &[S]
) -> Result<HistogramFast<T>, HistErrors> where
    S: Borrow<HistogramFast<T>>, 

Create a histogram, which encapsulates the histograms passed

pub fn align<S>(&self, right: S) -> Result<usize, HistErrors> where
    S: Borrow<HistogramFast<T>>, 

Get bin difference between histograms

impl<T> HistogramIntervalDistance<T> for HistogramFast<T> where
    T: PartialOrd<T> + Sub<T, Output = T> + NumCast + Copy,
    HistogramFast<T>: HistogramVal<T>, 

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

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

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

pub fn overlapping_partition(
    &self,
    n: usize,
    overlap: usize
) -> Result<Vec<HistogramFast<T>, Global>, HistErrors>

partition the interval

impl<T> HistogramVal<T> for HistogramFast<T> where
    T: PartialOrd<T> + CheckedSub + CheckedAdd + One + Saturating + NumCast + Copy,
    RangeInclusive<T>: Iterator,
    <RangeInclusive<T> as Iterator>::Item == T, 

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

Creates a vector containing borders (last border is exclusive)

• returns Err(Overflow) if right border is T::MAX
• creates and returns borders otherwise
• Note: even if Err(Overflow) is returned, this does not provide any problems for the rest of the implementation, as the border vector is not used internally for HistogramFast

pub fn first_border(&self) -> T

get the left most border (inclusive)

pub 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])

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

calculates some sort of absolute distance to the nearest valid bin

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

convert val to the respective histogram index

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

does a value correspond to a valid bin?

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

opposite of is_inside

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

count val. Some(index), if inside of hist, None if val is invalid

impl<T> Serialize for HistogramFast<T> where
    T: Serialize, 

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