Trait opensrdk_probability::distribution::Distribution

pub trait Distribution {
    type T: RandomVariable;
    type U: RandomVariable;
    fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>;
    fn sample(
        &self, 
        theta: &Self::U, 
        rng: &mut StdRng
    ) -> Result<Self::T, Box<dyn Error>>;

    fn ln_p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>> { ... }
}

Distribution

Associated Types

type T: RandomVariable

type U: RandomVariable

Loading content...

Required methods

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

Loading content...

Provided methods

fn ln_p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

Loading content...

Implementors

impl Distribution for Beta

type T = f64

type U = BetaParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for ChiSquared

type T = f64

type U = ChiSquaredParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Exp

type T = f64

type U = ExpParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for FisherF

type T = f64

type U = FisherFParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Gamma

type T = f64

type U = GammaParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Dirichlet

type T = Vec<f64>

type U = DirichletParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for InverseWishart

type T = Matrix

type U = InverseWishartParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

x must be cholesky decomposed

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

output is cholesky decomposed

impl Distribution for MultivariateNormal

type T = Vec<f64>

type U = MultivariateNormalParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for MultivariateStudentT

type T = Vec<f64>

type U = MultivariateStudentTParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for NormalInverseWishart

type T = MultivariateNormalParams

type U = NormalInverseWishartParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Wishart

type T = Matrix

type U = WishartParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

x must be cholesky decomposed

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

output is cholesky decomposed

impl Distribution for Normal

type T = f64

type U = NormalParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for StudentT

type T = f64

type U = StudentTParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Binominal

type T = u64

type U = BinominalParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Geometric

type T = u64

type U = GeometricParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for Poisson

type T = u64

type U = PoissonParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl Distribution for ChineseRestaurantDP

type T = u64

type U = ChineseRestaurantDPParams

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<'a, T, U> Distribution for InstantDistribution<'a, T, U> where
    T: RandomVariable,
    U: RandomVariable, 

type T = T

type U = U

fn p(&self, x: &T, theta: &U) -> Result<f64, Box<dyn Error>>

fn sample(&self, theta: &U, rng: &mut StdRng) -> Result<T, Box<dyn Error>>

impl<D, T1, T2, U> Distribution for ConvertedDistribution<D, T1, T2, U> where
    D: Distribution<T = T1, U = U>,
    T1: RandomVariable,
    T2: RandomVariable,
    U: RandomVariable, 

type T = T2

type U = U

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<D, T, U> Distribution for IndependentArrayJoint<D, T, U> where
    D: Distribution<T = T, U = U>,
    T: RandomVariable,
    U: RandomVariable, 

type T = Vec<T>

type U = U

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<G, K, T> Distribution for StudentTP<G, K, T> where
    G: GaussianProcess<K, T>,
    K: Kernel<T>,
    T: RandomVariable, 

type T = Vec<f64>

type U = StudentTPParams<T>

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<K, T> Distribution for ExactGP<K, T> where
    K: Kernel<T>,
    T: RandomVariable, 

type T = Vec<f64>

type U = GaussianProcessParams<T>

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<K, T> Distribution for KissLoveGP<K, T> where
    K: Kernel<Vec<f64>>,
    T: Convolutable + PartialEq, 

type T = Vec<f64>

type U = GaussianProcessParams<T>

fn p(&self, x: &Self::T, theta: &Self::U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &Self::U,
    rng: &mut StdRng
) -> Result<Self::T, Box<dyn Error>>

impl<L, R, T, UL, UR> Distribution for DependentJoint<L, R, T, UL, UR> where
    L: Distribution<T = T, U = UL>,
    R: Distribution<T = UL, U = UR>,
    T: RandomVariable,
    UL: RandomVariable,
    UR: RandomVariable, 

type T = (T, UL)

type U = UR

fn p(&self, x: &(T, UL), theta: &UR) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &UR,
    rng: &mut StdRng
) -> Result<(T, UL), Box<dyn Error>>

impl<L, R, TL, TR, U> Distribution for IndependentJoint<L, R, TL, TR, U> where
    L: Distribution<T = TL, U = U>,
    R: Distribution<T = TR, U = U>,
    TL: RandomVariable,
    TR: RandomVariable,
    U: RandomVariable, 

type T = (TL, TR)

type U = U

fn p(&self, x: &(TL, TR), theta: &U) -> Result<f64, Box<dyn Error>>

fn sample(
    &self,
    theta: &U,
    rng: &mut StdRng
) -> Result<(TL, TR), Box<dyn Error>>

impl<T> Distribution for Constant<T> where
    T: RandomVariable, 

type T = T

type U = ()

fn p(&self, x: &T, _: &()) -> Result<f64, Box<dyn Error>>

fn sample(&self, _: &(), _: &mut StdRng) -> Result<T, Box<dyn Error>>

Loading content...