Struct BinningWithWidth

pub struct BinningWithWidth<T>
where
    T: HasUnsignedVersion,
{ /* private fields */ }

Generic binning meant for any integer type

Implementations

impl BinningWithWidth<u8>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> u8

Get left border, inclusive

pub const fn right(&self) -> u8

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<u8>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<u8>>( &self, val: V, ) -> Option<<u8 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<i8>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> i8

Get left border, inclusive

pub const fn right(&self) -> i8

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<i8>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<i8>>( &self, val: V, ) -> Option<<i8 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<u16>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> u16

Get left border, inclusive

pub const fn right(&self) -> u16

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<u16>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<u16>>( &self, val: V, ) -> Option<<u16 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<i16>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> i16

Get left border, inclusive

pub const fn right(&self) -> i16

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<i16>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<i16>>( &self, val: V, ) -> Option<<i16 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<u32>

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 bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<u32>

Example:

use sampling::histogram::BinningU32;
let binning = BinningU32::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.native_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 of width 1 and are going over the entire range of the type, then we 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

impl BinningWithWidth<i32>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> i32

Get left border, inclusive

pub const fn right(&self) -> i32

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<i32>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<i32>>( &self, val: V, ) -> Option<<i32 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<u64>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<u64>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<u64>>( &self, val: V, ) -> Option<<u64 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<i64>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> i64

Get left border, inclusive

pub const fn right(&self) -> i64

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<i64>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<i64>>( &self, val: V, ) -> Option<<i64 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<u128>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> u128

Get left border, inclusive

pub const fn right(&self) -> u128

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<u128>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<u128>>( &self, val: V, ) -> Option<<u128 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<i128>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> i128

Get left border, inclusive

pub const fn right(&self) -> i128

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<i128>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<i128>>( &self, val: V, ) -> Option<<i128 as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<usize>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

pub const fn left(&self) -> usize

Get left border, inclusive

pub const fn right(&self) -> usize

Get right border, inclusive

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

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<usize>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<usize>>( &self, val: V, ) -> Option<<usize as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

impl BinningWithWidth<isize>

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

Create a new Binning

• both borders are inclusive
• each bin has width bin_width

Panics

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

Err

Result is Err if start and end are mismatched with the bin_width, i.e., it is impossible to create the binning due to the integer nature of our types

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

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

Iterator over all the bins

Here the bins are represented as RangeInclusive<isize>

Example:

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

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

The amount of bins -1

• minus 1 because if the bins are of width 1 and are going over the entire range of the type, then we 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<isize>>( &self, val: V, ) -> Option<<isize as HasUnsignedVersion>::Unsigned>

Get the respective bin in native unsigned

Trait Implementations

impl<T> Clone for BinningWithWidth<T>

where T: HasUnsignedVersion + Clone, T::Unsigned: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BinningWithWidth<T>

where T: HasUnsignedVersion + Debug, T::Unsigned: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for BinningWithWidth<T>

where T: HasUnsignedVersion + Deserialize<'de>, T::Unsigned: 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> PartialEq for BinningWithWidth<T>

where T: HasUnsignedVersion + PartialEq, T::Unsigned: PartialEq,

fn eq(&self, other: &BinningWithWidth<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> Serialize for BinningWithWidth<T>

where T: HasUnsignedVersion + Serialize, T::Unsigned: 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> Eq for BinningWithWidth<T>

where T: HasUnsignedVersion + Eq, T::Unsigned: Eq,

impl<T> StructuralPartialEq for BinningWithWidth<T>

where T: HasUnsignedVersion,