Struct uncertain::Distribution

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

Wraps a Distribution and implements Uncertain.

Uncertain values need to observe the correct epoch semantics if they implement Copy or Clone, or want to implement Uncertain for references. Since most uncertain values model distributions but distributions themselves do not require any special epoch semantics when they can be Cloned or are implemented on references, this wrapper type exists.

See Uncertain::sample for more details on the required semantics.

Examples

Basic usage:

use uncertain::{Uncertain, Distribution};
use rand_distr::StandardNormal;

let x = Distribution::from(StandardNormal);
assert!(x.map(|x: f64| x.abs() < 1.0).pr(0.68));

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(&self, rng: &mut Pcg32, _epoch: usize) -> Self::Value

Generate a random sample from the distribution of 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 expect(
    &self,
    precision: Self::Value
) -> Result<Self::Value, ConvergenceError<Self::Value>> where
    Self::Value: Float, 

Calculate the expectation of this uncertain value to the desired precision. This can be useful e.g. when displaying values in a user interface.

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

Box this uncertain value, such that it’s type becomes opaque. This is necessary when you want to mix different sources for uncertain values e.g. to return different distributions inside flat_map.

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).