Struct bio::stats::bayesian::model::Model

pub struct Model<L, Pr, Po, Payload = ()>
where
    L: Likelihood<Payload>,
    Pr: Prior,
    Po: Posterior,
    Payload: Default,
{ /* private fields */ }

Bayesian model, consisting of a prior, a posterior and a likelihood model. Thereby, Payload is a custom payload of the model instance. This can be used to define custom caching mechanisms. See here for an example.

Implementations

impl<Event, PosteriorEvent, Data, L, Pr, Po, Payload> Model<L, Pr, Po, Payload>

where Payload: Default, Event: Hash + Eq + Clone, PosteriorEvent: Hash + Eq + Clone, L: Likelihood<Payload, Event = Event, Data = Data>, Pr: Prior<Event = Event>, Po: Posterior<BaseEvent = Event, Event = PosteriorEvent, Data = Data>,

pub fn new(likelihood: L, prior: Pr, posterior: Po) -> Self

Create new instance.

pub fn likelihood(&self) -> &L

pub fn likelihood_mut(&mut self) -> &mut L

pub fn prior(&self) -> &Pr

pub fn prior_mut(&mut self) -> &mut Pr

pub fn posterior(&self) -> &Po

pub fn posterior_mut(&mut self) -> &mut Po

pub fn compute<U: IntoIterator<Item = PosteriorEvent>>( &self, universe: U, data: &Data ) -> ModelInstance<Event, PosteriorEvent>

Compute model for a given universe of events.

pub fn compute_from_marginal<M>( &self, marginal: &M, data: &Data ) -> ModelInstance<Event, PosteriorEvent>

where M: Marginal<Data = Data, Event = PosteriorEvent, BaseEvent = Event>,

Compute model via the exploration of the marginal distribution of the data.

Trait Implementations

impl<L, Pr, Po, Payload> Clone for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Clone, Pr: Prior + Clone, Po: Posterior + Clone, Payload: Default + Clone,

fn clone(&self) -> Model<L, Pr, Po, Payload>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, Pr, Po, Payload> Debug for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Debug, Pr: Prior + Debug, Po: Posterior + Debug, Payload: Default + Debug,

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

Formats the value using the given formatter.

impl<L, Pr, Po, Payload> Default for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Default, Pr: Prior + Default, Po: Posterior + Default, Payload: Default + Default,

fn default() -> Model<L, Pr, Po, Payload>

Returns the “default value” for a type.

impl<'de, L, Pr, Po, Payload> Deserialize<'de> for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Deserialize<'de>, Pr: Prior + Deserialize<'de>, Po: Posterior + Deserialize<'de>, Payload: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<L, Pr, Po, Payload> Hash for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Hash, Pr: Prior + Hash, Po: Posterior + Hash, Payload: Default + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L, Pr, Po, Payload> Ord for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Ord, Pr: Prior + Ord, Po: Posterior + Ord, Payload: Default + Ord,

fn cmp(&self, other: &Model<L, Pr, Po, Payload>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<L, Pr, Po, Payload> PartialEq for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + PartialEq, Pr: Prior + PartialEq, Po: Posterior + PartialEq, Payload: Default + PartialEq,

fn eq(&self, other: &Model<L, Pr, Po, Payload>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<L, Pr, Po, Payload> PartialOrd for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + PartialOrd, Pr: Prior + PartialOrd, Po: Posterior + PartialOrd, Payload: Default + PartialOrd,

fn partial_cmp(&self, other: &Model<L, Pr, Po, Payload>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<L, Pr, Po, Payload> Serialize for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Serialize, Pr: Prior + Serialize, Po: Posterior + Serialize, Payload: Default,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<L, Pr, Po, Payload> Copy for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Copy, Pr: Prior + Copy, Po: Posterior + Copy, Payload: Default + Copy,

impl<L, Pr, Po, Payload> Eq for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload> + Eq, Pr: Prior + Eq, Po: Posterior + Eq, Payload: Default + Eq,

impl<L, Pr, Po, Payload> StructuralPartialEq for Model<L, Pr, Po, Payload>

where L: Likelihood<Payload>, Pr: Prior, Po: Posterior, Payload: Default,