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<X> Clone for UniformFloat<X>

where X: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X> Debug for UniformFloat<X>

where X: Debug,

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

Formats the value using the given formatter.

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

where X: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X> PartialEq for UniformFloat<X>

where X: PartialEq,

fn eq(&self, other: &UniformFloat<X>) -> 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<X> Serialize for UniformFloat<X>

where X: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UniformSampler for UniformFloat<Simd<f32, 16>>

type X = Simd<f32, 16>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 16>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 16>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f32, 16>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 16>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f32, 2>>

type X = Simd<f32, 2>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 2>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 2>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f32, 2>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 2>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f32, 4>>

type X = Simd<f32, 4>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 4>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 4>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f32, 4>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 4>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f32, 8>>

type X = Simd<f32, 8>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 8>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f32, 8>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f32, 8>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f32, 8>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f64, 2>>

type X = Simd<f64, 2>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 2>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 2>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f64, 2>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 2>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f64, 4>>

type X = Simd<f64, 4>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 4>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 4>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f64, 4>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 4>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<Simd<f64, 8>>

type X = Simd<f64, 8>

The type sampled by this implementation.

fn new<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 8>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<Simd<f64, 8>>, Error>

where B1: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>( &self, rng: &mut R, ) -> <UniformFloat<Simd<f64, 8>> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<Simd<f64, 8>> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<f32>

type X = f32

The type sampled by this implementation.

fn new<B1, B2>(low_b: B1, high_b: B2) -> Result<UniformFloat<f32>, Error>

where B1: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<f32>, Error>

where B1: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>(&self, rng: &mut R) -> <UniformFloat<f32> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<f32> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<f32> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f32> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl UniformSampler for UniformFloat<f64>

type X = f64

The type sampled by this implementation.

fn new<B1, B2>(low_b: B1, high_b: B2) -> Result<UniformFloat<f64>, Error>

where B1: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>,

Construct self, with inclusive lower bound and exclusive upper bound [low, high).

fn new_inclusive<B1, B2>( low_b: B1, high_b: B2, ) -> Result<UniformFloat<f64>, Error>

where B1: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>,

Construct self, with inclusive bounds [low, high].

fn sample<R>(&self, rng: &mut R) -> <UniformFloat<f64> as UniformSampler>::X

where R: Rng + ?Sized,

Sample a value.

fn sample_single<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<f64> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and exclusive upper bound [low, high).

fn sample_single_inclusive<R, B1, B2>( low_b: B1, high_b: B2, rng: &mut R, ) -> Result<<UniformFloat<f64> as UniformSampler>::X, Error>

where R: Rng + ?Sized, B1: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>, B2: SampleBorrow<<UniformFloat<f64> as UniformSampler>::X>,

Sample a single value uniformly from a range with inclusive lower bound and inclusive upper bound [low, high].

impl<X> Copy for UniformFloat<X>

where X: Copy,

impl<X> StructuralPartialEq for UniformFloat<X>