Struct opensrdk_probability::distribution::dependent_joint::DependentJoint

pub struct DependentJoint<L, R, T, UL, UR>where
    L: Distribution<Value = T, Condition = UL>,
    R: Distribution<Value = UL, Condition = UR>,
    T: RandomVariable,
    UL: Event,
    UR: Event,{ /* private fields */ }

p(x, y) = p(x | y) p(y)

Implementations

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

pub fn new(lhs: L, rhs: R) -> Self

Trait Implementations

impl<L, R, T, UL, UR, Rhs, URhs> BitAnd<Rhs> for DependentJoint<L, R, T, UL, UR>where
L: Distribution<Value = T, Condition = UL>,
R: Distribution<Value = UL, Condition = UR>,
T: RandomVariable,
UL: RandomVariable,
UR: RandomVariable,
Rhs: Distribution<Value = UR, Condition = URhs>,
URhs: RandomVariable,

type Output = DependentJoint<DependentJoint<L, R, T, UL, UR>, Rhs, (T, UL), UR, URhs>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

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

fn clone(&self) -> DependentJoint<L, R, T, UL, UR>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R, T, UL, UR> ConditionDifferentiableDistribution for DependentJoint<L, R, T, UL, UR>where
L: Distribution<Value = T, Condition = UL>,
R: Distribution<Value = UL, Condition = UR> + ConditionDifferentiableDistribution,
T: RandomVariable,
UL: RandomVariable,
UR: RandomVariable,

fn ln_diff_condition(
&self,
x: &Self::Value,
theta: &Self::Condition
) -> Result<Vec<f64>, DistributionError>

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

type Value = (T, UL)

type Condition = UR

fn p_kernel(&self, x: &(T, UL), theta: &UR) -> Result<f64, DistributionError>

impl<L, R, T, UL, UR, Rhs, TRhs> Mul<Rhs> for DependentJoint<L, R, T, UL, UR>where
L: Distribution<Value = T, Condition = UL>,
R: Distribution<Value = UL, Condition = UR>,
T: RandomVariable,
UL: RandomVariable,
UR: RandomVariable,
Rhs: Distribution<Value = TRhs, Condition = UR>,
TRhs: RandomVariable,

type Output = IndependentJoint<DependentJoint<L, R, T, UL, UR>, Rhs, (T, UL), TRhs, UR>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

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,

fn sample(
&self,
theta: &UR,
rng: &mut dyn RngCore
) -> Result<(T, UL), DistributionError>

impl<L, R, T, UL, UR> ValueDifferentiableDistribution for DependentJoint<L, R, T, UL, UR>where
L: Distribution<Value = T, Condition = UL> + ValueDifferentiableDistribution + ConditionDifferentiableDistribution,
R: Distribution<Value = UL, Condition = UR> + ValueDifferentiableDistribution + ConditionDifferentiableDistribution,
T: RandomVariable,
UL: RandomVariable,
UR: RandomVariable,

fn ln_diff_value(
&self,
x: &Self::Value,
theta: &Self::Condition
) -> Result<Vec<f64>, DistributionError>