Struct UniformFloat

pub struct UniformFloat<X> { /* private fields */ }

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.

Trait Implementations

impl UniformSampler for UniformFloat<f32>

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

impl UniformSampler for UniformFloat<f64>

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

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

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

impl<X> Serialize for UniformFloat<X> where X: Serialize,

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

impl<X: Clone> Clone for UniformFloat<X>

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

impl<X: Copy> Copy for UniformFloat<X>

impl<X: Debug> Debug for UniformFloat<X>

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

impl<X: PartialEq> PartialEq for UniformFloat<X>

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

impl<X: PartialEq> StructuralPartialEq for UniformFloat<X>

Auto Trait Implementations

impl<X> Freeze for UniformFloat<X> where X: Freeze + Freeze,

impl<X> RefUnwindSafe for UniformFloat<X> where X: RefUnwindSafe + RefUnwindSafe,

impl<X> Send for UniformFloat<X> where X: Send + Send,

impl<X> Sync for UniformFloat<X> where X: Sync + Sync,

impl<X> Unpin for UniformFloat<X> where X: Unpin + Unpin,

impl<X> UnsafeUnpin for UniformFloat<X> where X: UnsafeUnpin + UnsafeUnpin,

impl<X> UnwindSafe for UniformFloat<X> where X: UnwindSafe + UnwindSafe,

Blanket Implementations

impl<T> Any for UniformFloat<X> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for UniformFloat<X> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for UniformFloat<X> where T: ?Sized,

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

impl<T> CloneToUninit for UniformFloat<X> where T: Clone,

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

impl<T> DeserializeOwned for UniformFloat<X> where T: for<'de> Deserialize<'de>,

impl<T> From<T> for UniformFloat<X>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for UniformFloat<X> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for UniformFloat<X> where U: From<T>,

fn into(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<U> for UniformFloat<X> where U: Into<T>,

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

impl<T, U> TryInto<U> for UniformFloat<X> where U: TryFrom<T>,

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