Type Alias FastBinningISIZE

pub type FastBinningISIZE = FastSingleIntBinning<isize>;

Efficient binning for isize with bins of width 1

Aliased Type

struct FastBinningISIZE { /* private fields */ }

Implementations

impl FastBinningISIZE

pub const fn new_inclusive(start: isize, end_inclusive: isize) -> 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) -> isize

Get left border, inclusive

pub const fn right(&self) -> isize

Get right border, inclusive

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

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

pub fn native_bin_iter(&self) -> impl Iterator<Item = isize>

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

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

pub fn get_bin_index_native<V: Borrow<isize>>( &self, val: V, ) -> Option<<isize 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<isize> for FastBinningISIZE

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

Does a value correspond to a valid bin?

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

Opposite of is_inside

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

fn first_border(&self) -> isize

get the left most border (inclusive)

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

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) -> isize

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 FastBinningISIZE

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 isize 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 isize

impl<T: Clone> Clone for FastSingleIntBinning<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FastSingleIntBinning<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for FastSingleIntBinning<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: Ord> Ord for FastSingleIntBinning<T>

fn cmp(&self, other: &FastSingleIntBinning<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for FastSingleIntBinning<T>

fn eq(&self, other: &FastSingleIntBinning<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for FastSingleIntBinning<T>

fn partial_cmp(&self, other: &FastSingleIntBinning<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

impl<T: Copy> Copy for FastSingleIntBinning<T>

impl<T: Eq> Eq for FastSingleIntBinning<T>

impl<T> StructuralPartialEq for FastSingleIntBinning<T>