Type Alias 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

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

impl FastBinningU64

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

Get the respective bin index

• Similar to get_bin_index, but without the cast to usize. This means that large types are not at a risk of overflow here

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, in that case Some(usize::MAX) will be returned

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., native_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

If the last border is inclusive, this returns the largest value that is still inside the binning.If the last border is exclusive, this is the first value which is not inside the binning.

fn last_border_is_inclusive(&self) -> bool

True if last border is inclusive, false otherwise

fn to_generic_hist(self) -> GenericHist<Self, T>

where Self: Sized,

Convert binning into GenericHist

fn to_generic_atomic_hist(self) -> AtomicGenericHist<Self, T>

where Self: Sized,

Convert binning into a AtomicGenericHist

impl HistogramPartition for FastBinningU64

fn overlapping_partition( &self, n: NonZeroUsize, overlap: usize, ) -> Result<Vec<Self>, HistErrors>

partition the interval

• returns Vector of n Binnings. Though n will be limited by the max value that u64 can hold. ## parameter
• n number of resulting intervals.
• overlap How much overlap should there be?

To understand overlap, we have to look at the formula for the i_th interval in the result vector:

let left be the left border of self and right be the right border of self

• left border of interval i = left + i * (right - left) / (n + overlap)
• right border of interval i = left + (i + overlap) * (right - left) / (n + overlap)

What is it for?

• This is intended to create multiple overlapping intervals, e.g., for a Wang-Landau simulation

Note

• Will fail if overlap + n are not representable as u64