Struct UniformFloat

struct UniformFloat<X> { ... }

The back-end implementing UniformSampler for floating-point types.

Unless you are implementing UniformSampler for your own type, this type should not be used directly, use Uniform instead.

Implementation notes

UniformFloat implementations convert RNG output to a float in the range [1, 2) via transmutation, map this to [0, 1), then scale and translate to the desired range. Values produced this way have what equals 23 bits of random digits for an f32 and 52 for an f64.

Bias and range errors

Bias may be expected within the least-significant bit of the significand. It is not guaranteed that exclusive limits of a range are respected; i.e. when sampling the range [a, b) it is not guaranteed that b is never sampled.

Implementations

impl UniformSampler for UniformFloat<f32>

fn new<B1, B2>(low_b: B1, high_b: B2) -> Result<Self, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Result<Self, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn sample<R: Rng + ?Sized>(self: &Self, rng: &mut R) -> <Self as >::X
fn sample_single<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Result<<Self as >::X, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn sample_single_inclusive<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Result<<Self as >::X, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized

impl UniformSampler for UniformFloat<f64>

fn new<B1, B2>(low_b: B1, high_b: B2) -> Result<Self, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn new_inclusive<B1, B2>(low_b: B1, high_b: B2) -> Result<Self, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn sample<R: Rng + ?Sized>(self: &Self, rng: &mut R) -> <Self as >::X
fn sample_single<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Result<<Self as >::X, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized
fn sample_single_inclusive<R: Rng + ?Sized, B1, B2>(low_b: B1, high_b: B2, rng: &mut R) -> Result<<Self as >::X, Error>
where
    B1: SampleBorrow<<Self as >::X> + Sized,
    B2: SampleBorrow<<Self as >::X> + Sized

impl<'de, X> Deserialize for UniformFloat<X>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, <__D as >::Error>
where
    __D: Deserializer<'de>

impl<T> Any for UniformFloat<X>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for UniformFloat<X>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for UniformFloat<X>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for UniformFloat<X>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> DeserializeOwned for UniformFloat<X>

impl<T> From for UniformFloat<X>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for UniformFloat<X>

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for UniformFloat<X>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for UniformFloat<X>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for UniformFloat<X>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<V, T> VZip for UniformFloat<X>

fn vzip(self: Self) -> V

impl<X> Freeze for UniformFloat<X>

impl<X> RefUnwindSafe for UniformFloat<X>

impl<X> Send for UniformFloat<X>

impl<X> Serialize for UniformFloat<X>

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

impl<X> StructuralPartialEq for UniformFloat<X>

impl<X> Sync for UniformFloat<X>

impl<X> Unpin for UniformFloat<X>

impl<X> UnsafeUnpin for UniformFloat<X>

impl<X> UnwindSafe for UniformFloat<X>

impl<X: $crate::clone::Clone> Clone for UniformFloat<X>

fn clone(self: &Self) -> UniformFloat<X>

impl<X: $crate::cmp::PartialEq> PartialEq for UniformFloat<X>

fn eq(self: &Self, other: &UniformFloat<X>) -> bool

impl<X: $crate::fmt::Debug> Debug for UniformFloat<X>

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

impl<X: $crate::marker::Copy> Copy for UniformFloat<X>