Struct uncertain::PointMass

pub struct PointMass<T> where
    T: Clone,  { /* fields omitted */ }

An uncertain value which always yields the same value.

This type can be useful when fixed values should be conditionally returned e.g. from flat_map. If you only need a fixed value as part of an uncertain computation, consider using map.

Examples

Basic usage: conditional distribution.

use uncertain::{Uncertain, PointMass, Distribution};
use rand_distr::Normal;

let a = Distribution::from(Normal::new(2.0, 1.0).unwrap());
let b = a.flat_map(|a| if a < 1.5 {
    Distribution::from(Normal::new(0.0, 1.0).unwrap()).into_boxed()
} else {
    PointMass::new(1.0).into_boxed()
});
assert!(b.map(|b| b > 0.5).pr(0.9));

In most cases you can use map instead:

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

let x = 1.0;
let y = Distribution::<f64, _>::from(StandardNormal).into_ref();
let a = PointMass::new(x).add(&y);
let b = (&y).map(|v: f64| v + x);
assert!(a.join(b, |a, b| a == b).pr(0.999));

Implementations

impl<T> PointMass<T> where
    T: Clone, 

pub fn new(value: T) -> Self

Create a new PointMass centered on the given value.

Trait Implementations

impl<T: Clone> Clone for PointMass<T> where
    T: Clone, 

fn clone(&self) -> PointMass<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for PointMass<T> where
    T: Clone, 

impl<T> Uncertain for PointMass<T> where
    T: Clone, 

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