Struct TUniform 

pub struct TUniform<T: UnsignedInteger> { /* private fields */ }

The distribution $TUniform(1, -2^b, 2^b)$ is defined as follows, any value in the interval $\left[-2^b, 2^b\right]$ is selected with probability $\frac{1}{2^{b+1}}$, with the two end points $-2^b$ and $2^b$ being selected with probability $\frac{1}{2^{b+2}}$.

Implementations

impl<T: UnsignedInteger> TUniform<T>

pub const fn new(bound_log2: u32) -> Self

Construct a TUniform distribution see TUniform for behavior of randomly generated values.

Panics

Panics if bound_log2 is greater than the Scalar type number of bits minus two.

The reason for this is that with a higher bound_log2 it is impossible to distinguish between $-2^{bound_log2}$ and $2^{bound_log2}$ because of the 2’s complement representation of integers.

pub const fn try_new(bound_log2: u32) -> Result<Self, &'static str>

Construct a TUniform distribution see TUniform for behavior of randomly generated values.

Note

Returns an Err variant if bound_log2 is greater than the Scalar type number of bits minus two.

The reason for this is that with a higher bound_log2 it is impossible to distinguish between $-2^{bound_log2}$ and $2^{bound_log2}$ because of the 2’s complement representation of integers.

pub const fn bound_log2(&self) -> u32

pub fn min_value_inclusive(&self) -> T::Signed

pub fn max_value_inclusive(&self) -> T::Signed

pub fn variance(&self, modulus: f64) -> Variance

Trait Implementations

impl<T> BoundedDistribution<<T as UnsignedInteger>::Signed> for TUniform<T>

where T: UnsignedInteger,

fn low_bound(&self) -> Bound<T::Signed>

fn high_bound(&self) -> Bound<T::Signed>

fn contains(self, value: T) -> bool

where T: Numeric,

impl<T: Clone + UnsignedInteger> Clone for TUniform<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + UnsignedInteger> Debug for TUniform<T>

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

Formats the value using the given formatter.

impl<'de, T: UnsignedInteger> Deserialize<'de> for TUniform<T>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq + UnsignedInteger> PartialEq for TUniform<T>

fn eq(&self, other: &TUniform<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 RandomGenerable<TUniform<u128>> for u128

type CustomModulus = u128

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: TUniform<u128>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: TUniform<u128>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( _distribution: TUniform<u128>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _: TUniform<u128>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl RandomGenerable<TUniform<u16>> for u16

type CustomModulus = u16

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: TUniform<u16>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: TUniform<u16>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( _distribution: TUniform<u16>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _: TUniform<u16>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl RandomGenerable<TUniform<u32>> for u32

type CustomModulus = u32

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: TUniform<u32>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: TUniform<u32>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( _distribution: TUniform<u32>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _: TUniform<u32>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl RandomGenerable<TUniform<u64>> for u64

type CustomModulus = u64

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: TUniform<u64>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: TUniform<u64>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( _distribution: TUniform<u64>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _: TUniform<u64>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl RandomGenerable<TUniform<u8>> for u8

type CustomModulus = u8

fn generate_one<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, _: TUniform<u8>, ) -> Self

Generate a value from distribution.

fn generate_one_custom_modulus<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: TUniform<u8>, custom_modulus: Self::CustomModulus, ) -> Self

Generate a value from distribution modulo the given custom_modulus.

fn single_sample_success_probability( _distribution: TUniform<u8>, _modulus: Option<Self::CustomModulus>, ) -> f64

Return the probability to successfully generate a sample from the given distribution for the type the trait is implemented on.

fn single_sample_required_random_byte_count( _: TUniform<u8>, _modulus: Option<Self::CustomModulus>, ) -> usize

Return how many bytes coming from a CSPRNG are required to generate one sample even if that generation can fail.

fn fill_slice<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], )

fn fill_slice_custom_mod<G: ByteRandomGenerator>( generator: &mut RandomGenerator<G>, distribution: D, slice: &mut [Self], custom_modulus: Self::CustomModulus, )

impl<T: UnsignedInteger> Serialize for TUniform<T>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: UnsignedInteger> Unversionize for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl<T: UnsignedInteger> UnversionizeVec for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl<T: UnsignedInteger> Version for TUniform<T>

where u32: VersionizeOwned + Unversionize + Versionize, PhantomData<T>: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = TUniformVersion<'vers, T> where T: 'vers

type Owned = TUniformVersionOwned<T>

impl<T: UnsignedInteger> Versionize for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

type Versioned<'vers> = <TUniformVersions<T> as VersionsDispatch<TUniform<T>>>::Ref<'vers> where T: 'vers

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl<T: UnsignedInteger> VersionizeOwned for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

type VersionedOwned = <TUniformVersions<T> as VersionsDispatch<TUniform<T>>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl<T: UnsignedInteger> VersionizeSlice for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<TUniform<T> as Versionize>::Versioned<'vers>> where T: 'vers

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl<T: UnsignedInteger> VersionizeVec for TUniform<T>

where TUniformVersions<T>: VersionsDispatch<Self>,

type VersionedVec = Vec<<TUniform<T> as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl<T: UnsignedInteger> VersionsDispatch<TUniform<T>> for TUniformVersions<T>

where TUniform<T>: Version,

type Ref<'vers> = TUniformVersionsDispatch<'vers, T> where T: 'vers

type Owned = TUniformVersionsDispatchOwned<T>

impl<T: Copy + UnsignedInteger> Copy for TUniform<T>

impl<T: UnsignedInteger> Distribution for TUniform<T>

impl<T: Eq + UnsignedInteger> Eq for TUniform<T>

impl<T: UnsignedInteger> StructuralPartialEq for TUniform<T>