Type Alias sampling::histogram::BinningU32

pub type BinningU32 = BinningWithWidth<u32>;

Efficient binning for u32 with bins of width 1

Aliased Type

struct BinningU32 { /* private fields */ }

Implementations

impl BinningU32

pub fn new_inclusive( start: u32, end_inclusive: u32, bin_width: u32 ) -> Result<Self, <u32 as HasUnsignedVersion>::Unsigned>

Create a new Binning

• both borders are inclusive
• each bin has width 1

Panics

• if start is smaller than end_inclusive
• if bin_width <= 0

pub const fn left(&self) -> u32

Get left border, inclusive

pub const fn right(&self) -> u32

Get right border, inclusive

pub const fn range_inclusive(&self) -> RangeInclusive<u32>

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

pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u32, u32)>

Iterator over all the bins

Since the bins have width 1, a bin can be defined by its corresponding value which we can iterate over.

Example

use sampling::histogram::BinningU32;
let binning = BinningU32::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);

pub fn bins_m1(&self) -> <u32 as HasUnsignedVersion>::Unsigned

The amount of bins -1

• minus 1 because if the bins are going over the entire range of the type, then I cannot represent the number of bins as this type

Example

If we look at an u8 and the range from 0 to 255, then this is 256 bins, which cannot be represented as u8. To combat this, I return bins - 1. This works, because we always have at least 1 bin

pub fn get_bin_index_native<V: Borrow<u32>>( &self, val: V ) -> Option<<u32 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

Trait Implementations

impl Binning<u32> for BinningU32

fn get_bin_index<V: Borrow<u32>>(&self, val: V) -> Option<usize>

Get the respective bin index

• Note: Obviously this breaks when the bin index cannot be represented as usize

fn is_inside<V: Borrow<u32>>(&self, val: V) -> bool

Does a value correspond to a valid bin?

fn not_inside<V: Borrow<u32>>(&self, val: V) -> bool

Opposite of is_inside

• I could also have called this is_outside, but I didn’t

fn first_border(&self) -> u32

get the left most border (inclusive)

fn distance<V: Borrow<u32>>(&self, v: V) -> f64

calculates some sort of absolute distance to the nearest valid bin

• if a value corresponds to a valid bin, the distance is zero

fn bin_iter(&self) -> Box<dyn Iterator<Item = Bin<u32>>>

Iterates over all bins

• Note: This implementation usees a more efficient representations of the bins underneath, but is capable of returning the bins in this representation on request
• Note also that this Binning implements another method for the bin borders, i.e., multi_valued_bin_iter. Consider using that instead, as it is more efficient

fn get_bin_len(&self) -> usize

Get the number of underlying bins

fn last_border(&self) -> u32

get last border from the rightNote: this border might be inclusive or exclusive

fn last_border_is_inclusive(&self) -> bool

True if last border is inclusive, false otherwise