Trait opensrdk_probability::distribution::sampleable::SampleableDistribution

pub trait SampleableDistribution: Distribution {
    fn sample(
        &self,
        theta: &Self::Condition,
        rng: &mut dyn RngCore
    ) -> Result<Self::Value, DistributionError>;
}

Required Methods

fn sample(
    &self,
    theta: &Self::Condition,
    rng: &mut dyn RngCore
) -> Result<Self::Value, DistributionError>

Implementors

impl SampleableDistribution for Dirichlet

impl SampleableDistribution for Beta

impl SampleableDistribution for MultivariateCauchy

impl SampleableDistribution for Cauchy

impl SampleableDistribution for MultivariateNormal

impl SampleableDistribution for Normal

impl SampleableDistribution for MultivariateStudentT

impl SampleableDistribution for StudentT

impl SampleableDistribution for Exp

impl SampleableDistribution for FisherF

impl SampleableDistribution for InverseWishart

impl SampleableDistribution for NormalInverseWishart

impl SampleableDistribution for Wishart

impl SampleableDistribution for ChiSquared

impl SampleableDistribution for Gamma

impl SampleableDistribution for ContinuousUniform

impl SampleableDistribution for Geometric

impl SampleableDistribution for Bernoulli

impl SampleableDistribution for Categorical

impl SampleableDistribution for Binomial

impl SampleableDistribution for Multinominal

impl SampleableDistribution for Poisson

impl<'a, D, T, U> SampleableDistribution for SwitchedDistribution<'a, D, T, U>where
    D: SampleableDistribution<Value = T, Condition = U>,
    T: RandomVariable,
    U: Event,

impl<D, T1, T2, U, F> SampleableDistribution for ValuedDistribution<D, T1, T2, U, F>where
    D: SampleableDistribution<Value = T1, Condition = U>,
    T1: RandomVariable,
    T2: RandomVariable,
    U: Event,
    F: Fn(&T2) -> Result<T1, DistributionError> + Clone + Send + Sync,

impl<D, T1, T2, U, F, G> SampleableDistribution for ValueDifferentiableValuedDistribution<D, T1, T2, U, F, G>where
    D: Distribution<Value = T1, Condition = U>,
    T1: RandomVariable,
    T2: RandomVariable,
    U: Event,
    F: Fn(&T2) -> Result<T1, DistributionError> + Clone + Send + Sync,
    G: Fn(&T2) -> Matrix + Clone + Send + Sync,

impl<D, T, U1, U2, F> SampleableDistribution for ConditionedDistribution<D, T, U1, U2, F>where
    D: SampleableDistribution<Value = T, Condition = U1>,
    T: RandomVariable,
    U1: Event,
    U2: Event,
    F: Fn(&U2) -> Result<U1, DistributionError> + Clone + Send + Sync,

impl<D, T, U1, U2, F, G> SampleableDistribution for ConditionDifferentiableConditionedDistribution<D, T, U1, U2, F, G>where
    D: SampleableDistribution<Value = T, Condition = U1>,
    T: RandomVariable,
    U1: Event,
    U2: Event,
    F: Fn(&U2) -> Result<U1, DistributionError> + Clone + Send + Sync,
    G: Fn(&U2) -> Matrix + Clone + Send + Sync,

impl<D, T, U> SampleableDistribution for IndependentArrayJoint<D, T, U>where
    D: SampleableDistribution<Value = T, Condition = U>,
    T: RandomVariable,
    U: RandomVariable,

impl<D, T, U> SampleableDistribution for IndependentValueArrayJoint<D, T, U>where
    D: SampleableDistribution<Value = T, Condition = U>,
    T: RandomVariable,
    U: RandomVariable,

impl<D, T, U, V> SampleableDistribution for TransformedDistribution<D, T, U, V>where
    D: SampleableDistribution<Value = T, Condition = U>,
    T: RandomVariable,
    U: RandomVariable,
    V: RandomVariable,

impl<L, P, A, B> SampleableDistribution for DiscretePosterior<L, P, A, B>where
    L: Distribution<Value = A, Condition = B>,
    P: Distribution<Value = B, Condition = ()>,
    A: RandomVariable,
    B: RandomVariable + Eq + Hash,

impl<L, R, T, UL, UR> SampleableDistribution for DependentJoint<L, R, T, UL, UR>where
    L: SampleableDistribution<Value = T, Condition = UL>,
    R: SampleableDistribution<Value = UL, Condition = UR>,
    T: RandomVariable,
    UL: RandomVariable,
    UR: Event,

impl<L, R, TL, TR, U> SampleableDistribution for IndependentJoint<L, R, TL, TR, U>where
    L: SampleableDistribution<Value = TL, Condition = U>,
    R: SampleableDistribution<Value = TR, Condition = U>,
    TL: RandomVariable,
    TR: RandomVariable,
    U: Event,

impl<S, A, K> SampleableDistribution for GeneralizedKernelDensity<S, A, K>where
    S: RandomVariable,
    A: RandomVariable,
    K: PositiveDefiniteKernel<Vec<f64>>,

impl<T> SampleableDistribution for DiscreteUniform<T>where
    T: RandomVariable + Eq + Hash,

impl<T> SampleableDistribution for ContinuousSamplesDistribution<T>where
    T: RandomVariable + PartialEq,

impl<T> SampleableDistribution for Degenerate<T>where
    T: RandomVariable + PartialEq,

impl<T> SampleableDistribution for DiscreteSamplesDistribution<T>where
    T: RandomVariable + Eq + Hash,

impl<T, U, FF, FS> SampleableDistribution for InstantDistribution<T, U, FF, FS>where
    T: RandomVariable,
    U: RandomVariable,
    FF: Fn(&T, &U) -> Result<f64, DistributionError> + Clone + Send + Sync,
    FS: Fn(&U, &mut dyn RngCore) -> Result<T, DistributionError> + Clone + Send + Sync,

impl<T, U, FF, FS, G> SampleableDistribution for ConditionDifferentiableInstantDistribution<T, U, FF, FS, G>where
    T: RandomVariable,
    U: RandomVariable,
    FF: Fn(&T, &U) -> Result<f64, DistributionError> + Clone + Send + Sync,
    FS: Fn(&U, &mut dyn RngCore) -> Result<T, DistributionError> + Clone + Send + Sync,
    G: Fn(&T, &U) -> Result<Vec<f64>, DistributionError> + Clone + Send + Sync,

impl<T, U, FF, FS, G> SampleableDistribution for ValueDifferentiableInstantDistribution<T, U, FF, FS, G>where
    T: RandomVariable,
    U: RandomVariable,
    FF: Fn(&T, &U) -> Result<f64, DistributionError> + Clone + Send + Sync,
    FS: Fn(&U, &mut dyn RngCore) -> Result<T, DistributionError> + Clone + Send + Sync,
    G: Fn(&T, &U) -> Result<Vec<f64>, DistributionError> + Clone + Send + Sync,