Type Alias sampling::histogram::FastBinningU64

pub type FastBinningU64 = FastSingleIntBinning<u64>;

Efficient binning for u64 with bins of width 1

Aliased Type

struct FastBinningU64 { /* private fields */ }

Implementations

impl FastBinningU64

pub const fn new_inclusive(start: u64, end_inclusive: u64) -> Self

Create a new Binning

• both borders are inclusive
• each bin has width 1

Panics

• if start is smaller than end_inclusive TODO Think about if this should actually panic or return None

pub const fn left(&self) -> u64

Get left border, inclusive

pub const fn right(&self) -> u64

Get right border, inclusive

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

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

pub fn single_valued_bin_iter(&self) -> impl Iterator<Item = u64>

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::FastBinningU64;
let binning = FastBinningU64::new_inclusive(2,5);
let vec: Vec<_> = binning.single_valued_bin_iter().collect();
assert_eq!(&vec, &[2, 3, 4, 5]);

pub fn bins_m1(&self) -> <u64 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

Trait Implementations

impl Binning<u64> for FastBinningU64

fn get_bin_index<V: Borrow<u64>>(&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<u64>>(&self, val: V) -> bool

Does a value correspond to a valid bin?

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

Opposite of is_inside

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

fn first_border(&self) -> u64

get the left most border (inclusive)

fn distance<V: Borrow<u64>>(&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<u64>>>

Iterates over all bins

• Note: This implementation use more efficient representations of the bins underneath, but are capable of returning the bins in this representation on request
• Note also that this Binning implements another method for the bin borders, i.e., single_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) -> u64

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