Struct uncertain::Distribution

pub struct Distribution<T, D> where
    D: Distribution<T>,  { /* fields omitted */ }

Wraps a rand::distributions::Distribution to create uncertain values from probability distributions and ensure they have the correct Copy and Clone semantics.

Implementations

impl<T, D> Distribution<T, D> where
    D: Distribution<T>, 

pub fn from(dist: D) -> Self

Construct a new impl Uncertain from a distribution.

Trait Implementations

impl<T, D> From<D> for Distribution<T, D> where
    D: Distribution<T>, 

fn from(dist: D) -> Self

Performs the conversion.

impl<T, D> Uncertain for Distribution<T, D> where
    D: Distribution<T>, 

type Value = T

The type of the contained value.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R, _epoch: usize) -> Self::Value

Generate a random sample from the distribution underlying this uncertain value. This is similar to Distribution::sample, with one important difference:

fn pr(&self, probability: f32) -> bool where
    Self::Value: Into<bool>, 

Determine if the probability of obtaining true form this uncertain value is at least probability.

fn pr_with<R: Rng + ?Sized>(&self, rng: &mut R, probability: f32) -> bool where
    Self::Value: Into<bool>, 

Same as Uncertain::pr, but generic over the random number generator used to produce samples.

fn into_boxed(self) -> BoxedUncertain<Self> where
    Self: 'static + Sized,
    Self::Value: Clone, 

👎 Deprecated since 0.2.1:

Please use into_ref instead

Box this uncertain value, so it can be reused in a calculation. Usually, an uncertain value can not be cloned. To ensure that an uncertain value can be cloned safely, it has to cache it’s sampled value such that if it is queried for the same epoch twice, it returns the same value.

fn into_ref(self) -> RefUncertain<Self> where
    Self: Sized,
    Self::Value: Clone, 

Bundle this uncertain value with a cache, so it can be reused in a calculation.

fn map<O, F>(self, func: F) -> Map<Self, F> where
    Self: Sized,
    F: Fn(Self::Value) -> O, 

Takes an uncertain value and produces another which generates values by calling a closure.

fn flat_map<O, F>(self, func: F) -> FlatMap<Self, F> where
    Self: Sized,
    O: Uncertain,
    F: Fn(Self::Value) -> O, 

Takes an uncertain value and produces another which generates values by calling a closure to generate fresh uncertain types that can depend on the value contained in self.

fn join<O, U, F>(self, other: U, func: F) -> Join<Self, U, F> where
    Self: Sized,
    U: Uncertain,
    F: Fn(Self::Value, U::Value) -> O, 

Combine two uncertain values using a closure. The closure func receives self as the first, and other as the second argument.

fn not(self) -> Not<Self> where
    Self: Sized,
    Self::Value: Into<bool>, 

Negate the boolean contained in self. This is a shorthand for x.map(|b| !b).

fn and<U>(self, other: U) -> And<Self, U> where
    Self: Sized,
    Self::Value: Into<bool>,
    U: Uncertain,
    U::Value: Into<bool>, 

Combines two boolean values. This should be preferred over x.join(y, |x, y| x && y), since it uses short-circuit logic to avoid sampling y if x is already false.

fn or<U>(self, other: U) -> Or<Self, U> where
    Self: Sized,
    Self::Value: Into<bool>,
    U: Uncertain,
    U::Value: Into<bool>, 

Combines two boolean values. This should be preferred over x.join(y, |x, y| x || y), since it uses short-circuit logic to avoid sampling y if x is already true.

fn add<U>(self, other: U) -> Sum<Self, U> where
    Self: Sized,
    U: Uncertain,
    Self::Value: Add<U::Value>, 

Add two uncertain values. This is a shorthand for x.join(y, |x, y| x + y).

fn sub<U>(self, other: U) -> Difference<Self, U> where
    Self: Sized,
    U: Uncertain,
    Self::Value: Sub<U::Value>, 

Subtract two uncertain values. This is a shorthand for x.join(y, |x, y| x - y).

fn mul<U>(self, other: U) -> Product<Self, U> where
    Self: Sized,
    U: Uncertain,
    Self::Value: Mul<U::Value>, 

Multiply two uncertain values. This is a shorthand for x.join(y, |x, y| x * y).

fn div<U>(self, other: U) -> Ratio<Self, U> where
    Self: Sized,
    U: Uncertain,
    Self::Value: Div<U::Value>, 

Divide two uncertain values. This is a shorthand for x.join(y, |x, y| x / y).