Struct opensrdk_probability::distribution::instant_value_differentiable::ValueDifferentiableInstantDistribution

pub struct 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,{ /* private fields */ }

Implementations

impl<T, U, FF, FS, G> 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,

pub fn new(
instant_distribution: InstantDistribution<T, U, FF, FS>,
value_diff: G
) -> Self

Trait Implementations

impl<T, U, Rhs, URhs, FF, FS, G> BitAnd<Rhs> for ValueDifferentiableInstantDistribution<T, U, FF, FS, G>where
T: RandomVariable,
U: RandomVariable,
Rhs: Distribution<Value = U, Condition = URhs>,
URhs: 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,

type Output = DependentJoint<ValueDifferentiableInstantDistribution<T, U, FF, FS, G>, Rhs, T, U, URhs>

The resulting type after applying the & operator.

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

Performs the & operation.

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

fn clone(&self) -> ValueDifferentiableInstantDistribution<T, U, FF, FS, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U, FF, FS, G> Debug 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,

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

Formats the value using the given formatter.

impl<T, U, FF, FS, G> Distribution 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,

type Value = T

type Condition = U

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

impl<T, U, Rhs, TRhs, FF, FS, G> Mul<Rhs> for ValueDifferentiableInstantDistribution<T, U, FF, FS, G>where
T: RandomVariable,
U: RandomVariable,
Rhs: Distribution<Value = TRhs, Condition = U>,
TRhs: 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,

type Output = IndependentJoint<ValueDifferentiableInstantDistribution<T, U, FF, FS, G>, Rhs, T, TRhs, U>

The resulting type after applying the * operator.

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

Performs the * operation.

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,

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

impl<T, U, FF, FS, G> ValueDifferentiableDistribution 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,

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