Struct sampling::histogram::BinningWithWidth
source · pub struct BinningWithWidth<T>where
T: HasUnsignedVersion,{ /* private fields */ }
Expand description
Generic binning meant for any integer type
Implementations§
source§impl BinningWithWidth<u8>
impl BinningWithWidth<u8>
sourcepub fn new_inclusive(
start: u8,
end_inclusive: u8,
bin_width: u8
) -> Result<Self, <u8 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<u8>
pub const fn range_inclusive(&self) -> RangeInclusive<u8>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u8, u8)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u8, u8)>
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::BinningU8;
let binning = BinningU8::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <u8 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <u8 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
sourcepub fn get_bin_index_native<V: Borrow<u8>>(
&self,
val: V
) -> Option<<u8 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<u8>>( &self, val: V ) -> Option<<u8 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<i8>
impl BinningWithWidth<i8>
sourcepub fn new_inclusive(
start: i8,
end_inclusive: i8,
bin_width: i8
) -> Result<Self, <i8 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<i8>
pub const fn range_inclusive(&self) -> RangeInclusive<i8>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i8, i8)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i8, i8)>
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::BinningI8;
let binning = BinningI8::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <i8 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <i8 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
sourcepub fn get_bin_index_native<V: Borrow<i8>>(
&self,
val: V
) -> Option<<i8 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<i8>>( &self, val: V ) -> Option<<i8 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<u16>
impl BinningWithWidth<u16>
sourcepub fn new_inclusive(
start: u16,
end_inclusive: u16,
bin_width: u16
) -> Result<Self, <u16 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<u16>
pub const fn range_inclusive(&self) -> RangeInclusive<u16>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u16, u16)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u16, u16)>
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::BinningU16;
let binning = BinningU16::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <u16 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <u16 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
sourcepub fn get_bin_index_native<V: Borrow<u16>>(
&self,
val: V
) -> Option<<u16 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<u16>>( &self, val: V ) -> Option<<u16 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<i16>
impl BinningWithWidth<i16>
sourcepub fn new_inclusive(
start: i16,
end_inclusive: i16,
bin_width: i16
) -> Result<Self, <i16 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<i16>
pub const fn range_inclusive(&self) -> RangeInclusive<i16>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i16, i16)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i16, i16)>
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::BinningI16;
let binning = BinningI16::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <i16 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <i16 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
sourcepub fn get_bin_index_native<V: Borrow<i16>>(
&self,
val: V
) -> Option<<i16 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<i16>>( &self, val: V ) -> Option<<i16 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<u32>
impl BinningWithWidth<u32>
sourcepub fn new_inclusive(
start: u32,
end_inclusive: u32,
bin_width: u32
) -> Result<Self, <u32 as HasUnsignedVersion>::Unsigned>
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 thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<u32>
pub const fn range_inclusive(&self) -> RangeInclusive<u32>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u32, u32)>
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)]);
sourcepub fn bins_m1(&self) -> <u32 as HasUnsignedVersion>::Unsigned
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
sourcepub fn get_bin_index_native<V: Borrow<u32>>(
&self,
val: V
) -> Option<<u32 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<u32>>( &self, val: V ) -> Option<<u32 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<i32>
impl BinningWithWidth<i32>
sourcepub fn new_inclusive(
start: i32,
end_inclusive: i32,
bin_width: i32
) -> Result<Self, <i32 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<i32>
pub const fn range_inclusive(&self) -> RangeInclusive<i32>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i32, i32)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i32, i32)>
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::BinningI32;
let binning = BinningI32::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <i32 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <i32 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
sourcepub fn get_bin_index_native<V: Borrow<i32>>(
&self,
val: V
) -> Option<<i32 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<i32>>( &self, val: V ) -> Option<<i32 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<u64>
impl BinningWithWidth<u64>
sourcepub fn new_inclusive(
start: u64,
end_inclusive: u64,
bin_width: u64
) -> Result<Self, <u64 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<u64>
pub const fn range_inclusive(&self) -> RangeInclusive<u64>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u64, u64)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u64, 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::BinningU64;
let binning = BinningU64::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <u64 as HasUnsignedVersion>::Unsigned
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
sourcepub fn get_bin_index_native<V: Borrow<u64>>(
&self,
val: V
) -> Option<<u64 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<u64>>( &self, val: V ) -> Option<<u64 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<i64>
impl BinningWithWidth<i64>
sourcepub fn new_inclusive(
start: i64,
end_inclusive: i64,
bin_width: i64
) -> Result<Self, <i64 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<i64>
pub const fn range_inclusive(&self) -> RangeInclusive<i64>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i64, i64)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i64, i64)>
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::BinningI64;
let binning = BinningI64::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <i64 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <i64 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
sourcepub fn get_bin_index_native<V: Borrow<i64>>(
&self,
val: V
) -> Option<<i64 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<i64>>( &self, val: V ) -> Option<<i64 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<u128>
impl BinningWithWidth<u128>
sourcepub fn new_inclusive(
start: u128,
end_inclusive: u128,
bin_width: u128
) -> Result<Self, <u128 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<u128>
pub const fn range_inclusive(&self) -> RangeInclusive<u128>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u128, u128)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (u128, u128)>
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::BinningU128;
let binning = BinningU128::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <u128 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <u128 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
sourcepub fn get_bin_index_native<V: Borrow<u128>>(
&self,
val: V
) -> Option<<u128 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<u128>>( &self, val: V ) -> Option<<u128 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<i128>
impl BinningWithWidth<i128>
sourcepub fn new_inclusive(
start: i128,
end_inclusive: i128,
bin_width: i128
) -> Result<Self, <i128 as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<i128>
pub const fn range_inclusive(&self) -> RangeInclusive<i128>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i128, i128)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (i128, i128)>
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::BinningI128;
let binning = BinningI128::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <i128 as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <i128 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
sourcepub fn get_bin_index_native<V: Borrow<i128>>(
&self,
val: V
) -> Option<<i128 as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<i128>>( &self, val: V ) -> Option<<i128 as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<usize>
impl BinningWithWidth<usize>
sourcepub fn new_inclusive(
start: usize,
end_inclusive: usize,
bin_width: usize
) -> Result<Self, <usize as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<usize>
pub const fn range_inclusive(&self) -> RangeInclusive<usize>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (usize, usize)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (usize, usize)>
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::BinningUSIZE;
let binning = BinningUSIZE::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <usize as HasUnsignedVersion>::Unsigned
pub fn bins_m1(&self) -> <usize 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
sourcepub fn get_bin_index_native<V: Borrow<usize>>(
&self,
val: V
) -> Option<<usize as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<usize>>( &self, val: V ) -> Option<<usize as HasUnsignedVersion>::Unsigned>
source§impl BinningWithWidth<isize>
impl BinningWithWidth<isize>
sourcepub fn new_inclusive(
start: isize,
end_inclusive: isize,
bin_width: isize
) -> Result<Self, <isize as HasUnsignedVersion>::Unsigned>
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 1
Panics
- if
start
is smaller thanend_inclusive
- if bin_width <= 0
sourcepub const fn range_inclusive(&self) -> RangeInclusive<isize>
pub const fn range_inclusive(&self) -> RangeInclusive<isize>
sourcepub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (isize, isize)>
pub fn multi_valued_bin_iter(&self) -> impl Iterator<Item = (isize, 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::BinningISIZE;
let binning = BinningISIZE::new_inclusive(2,7,2).unwrap();
let vec: Vec<_> = binning.multi_valued_bin_iter().collect();
assert_eq!(&vec, &[(2, 3), (4, 5), (6, 7)]);
sourcepub fn bins_m1(&self) -> <isize as HasUnsignedVersion>::Unsigned
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
sourcepub fn get_bin_index_native<V: Borrow<isize>>(
&self,
val: V
) -> Option<<isize as HasUnsignedVersion>::Unsigned>
pub fn get_bin_index_native<V: Borrow<isize>>( &self, val: V ) -> Option<<isize as HasUnsignedVersion>::Unsigned>
Trait Implementations§
source§impl<T> Clone for BinningWithWidth<T>where
T: HasUnsignedVersion + Clone,
impl<T> Clone for BinningWithWidth<T>where
T: HasUnsignedVersion + Clone,
source§fn clone(&self) -> BinningWithWidth<T>
fn clone(&self) -> BinningWithWidth<T>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<T> Debug for BinningWithWidth<T>where
T: HasUnsignedVersion + Debug,
impl<T> Debug for BinningWithWidth<T>where
T: HasUnsignedVersion + Debug,
source§impl<'de, T> Deserialize<'de> for BinningWithWidth<T>where
T: HasUnsignedVersion + Deserialize<'de>,
impl<'de, T> Deserialize<'de> for BinningWithWidth<T>where
T: HasUnsignedVersion + Deserialize<'de>,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
source§impl<T> PartialEq for BinningWithWidth<T>where
T: HasUnsignedVersion + PartialEq,
impl<T> PartialEq for BinningWithWidth<T>where
T: HasUnsignedVersion + PartialEq,
source§fn eq(&self, other: &BinningWithWidth<T>) -> bool
fn eq(&self, other: &BinningWithWidth<T>) -> bool
self
and other
values to be equal, and is used
by ==
.