Struct rv::dist::Mixture

pub struct Mixture<Fx> { /* private fields */ }

Mixture distribution Σ w_i f(x|θ_i)

A mixture distribution is a convex combination of distributions.

Example

A bimodal Gaussian mixture model

use rv::prelude::*;

let g1 = Gaussian::new(-2.5, 1.0).unwrap();
let g2 = Gaussian::new(2.0, 2.1).unwrap();

// f(x) = 0.6 * N(-2.5, 1.0) + 0.4 * N(2.0, 2.1)
let mm = Mixture::new(vec![0.6, 0.4], vec![g1, g2]).unwrap();

Implementations

impl<Fx> Mixture<Fx>

pub fn new(weights: Vec<f64>, components: Vec<Fx>) -> Result<Self, MixtureError>

Create a new mixture distribution

Arguments

• weights: The weights for each component distribution. All entries must be positive and sum to 1.
• components: The component distributions.

pub fn ln_weights(&self) -> &[f64]

pub fn new_unchecked(weights: Vec<f64>, components: Vec<Fx>) -> Self

Creates a new Mixture without checking whether the parameters are valid.

pub fn uniform(components: Vec<Fx>) -> Result<Self, MixtureError>

Assume uniform component weights

Given a n-length vector of components, automatically sets the component weights to 1/n.

pub fn combine(mixtures: Vec<Mixture<Fx>>) -> Self

Combines many mixtures into one big mixture

Notes

Assumes mixtures are valid.

pub fn k(&self) -> usize

Number of components

pub fn weights(&self) -> &Vec<f64>

Get a reference to the component weights

pub fn components(&self) -> &Vec<Fx>

Get a reference to the components

pub fn set_weights(&mut self, weights: Vec<f64>) -> Result<(), MixtureError>

Set the mixture weights

Example

use rv::dist::Gaussian;

let components = vec![
    Gaussian::new(-2.0, 1.0).unwrap(),
    Gaussian::new(2.0, 1.0).unwrap(),
];

let mut mm = Mixture::uniform(components).unwrap();
assert_eq!(mm.weights(), &vec![0.5, 0.5]);

mm.set_weights(vec![0.2, 0.8]).unwrap();
assert_eq!(mm.weights(), &vec![0.2, 0.8]);

Will error for invalid weights

// This is fine
assert!(mm.set_weights(vec![0.2, 0.8]).is_ok());

// Does not sum to 1
assert!(mm.set_weights(vec![0.1, 0.8]).is_err());

// Wrong number of weights
assert!(mm.set_weights(vec![0.1, 0.1, 0.8]).is_err());

// Negative weight
assert!(mm.set_weights(vec![-0.1, 1.1]).is_err());

// Zero weight are ok
assert!(mm.set_weights(vec![0.0, 1.0]).is_ok());

pub fn set_weights_unchecked(&mut self, weights: Vec<f64>)

pub fn set_components( &mut self, components: Vec<Fx> ) -> Result<(), MixtureError>

Set the mixture components

Example

use rv::dist::Gaussian;
use rv::traits::Mean;

let components = vec![
    Gaussian::new(-2.0, 1.0).unwrap(),
    Gaussian::new(2.0, 1.0).unwrap(),
];

let mut mm = Mixture::uniform(components).unwrap();
let mean_1: f64 = mm.mean().unwrap();
assert_eq!(mean_1, 0.0);

let components_2 = vec![
    Gaussian::new(-3.0, 1.0).unwrap(),
    Gaussian::new(2.0, 1.0).unwrap(),
];
mm.set_components(components_2).unwrap();
let mean_2: f64 = mm.mean().unwrap();
assert_eq!(mean_2, -0.5);

pub fn set_components_unchecked(&mut self, components: Vec<Fx>)

Trait Implementations

impl<X, Fx> Cdf<X> for Mixture<Fx>

where Fx: Rv<X> + Cdf<X>,

fn cdf(&self, x: &X) -> f64

The value of the Cumulative Density Function at x

fn sf(&self, x: &X) -> f64

Survival function, 1 - CDF(x)

impl<Fx: Clone> Clone for Mixture<Fx>

fn clone(&self) -> Mixture<Fx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<X, Fx> ContinuousDistr<X> for Mixture<Fx>

where Fx: Rv<X> + ContinuousDistr<X>,

fn pdf(&self, x: &X) -> f64

The value of the Probability Density Function (PDF) at x

fn ln_pdf(&self, x: &X) -> f64

The value of the log Probability Density Function (PDF) at x

impl<Fx: Debug> Debug for Mixture<Fx>

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

Formats the value using the given formatter.

impl<'de, Fx> Deserialize<'de> for Mixture<Fx>

where Fx: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<X, Fx> DiscreteDistr<X> for Mixture<Fx>

where Fx: Rv<X> + DiscreteDistr<X>,

fn pmf(&self, x: &X) -> f64

Probability mass function (PMF) at x

fn ln_pmf(&self, x: &X) -> f64

Natural logarithm of the probability mass function (PMF)

impl Entropy for Mixture<Bernoulli>

fn entropy(&self) -> f64

The entropy, H(X)

impl Entropy for Mixture<Categorical>

fn entropy(&self) -> f64

The entropy, H(X)

impl Entropy for Mixture<Gaussian>

fn entropy(&self) -> f64

The entropy, H(X)

impl Entropy for Mixture<Poisson>

fn entropy(&self) -> f64

The entropy, H(X)

impl<Fx> From<Mixture<Fx>> for Vec<(f64, Fx)>

fn from(mm: Mixture<Fx>) -> Self

Converts to this type from the input type.

impl<Fx> Mean<f32> for Mixture<Fx>

where Fx: Mean<f32>,

fn mean(&self) -> Option<f32>

Returns None if the mean is undefined

impl<Fx> Mean<f64> for Mixture<Fx>

where Fx: Mean<f64>,

fn mean(&self) -> Option<f64>

Returns None if the mean is undefined

impl<Fx: PartialEq> PartialEq for Mixture<Fx>

fn eq(&self, other: &Mixture<Fx>) -> 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 QuadBounds for Mixture<Gaussian>

fn quad_bounds(&self) -> (f64, f64)

impl QuadBounds for Mixture<Poisson>

fn quad_bounds(&self) -> (f64, f64)

impl Rv<Datum> for Mixture<Vec<Distribution>>

fn ln_f(&self, x: &Datum) -> f64

Probability function

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<Datum>

Multiple draws of the Rv

fn draw<R: Rng>(&self, rng: &mut R) -> Datum

Single draw from the Rv

fn f(&self, x: &X) -> f64

Probability function

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl<X, Fx> Rv<X> for Mixture<Fx>

where Fx: Rv<X>,

fn ln_f(&self, x: &X) -> f64

Probability function

fn f(&self, x: &X) -> f64

Probability function

fn draw<R: Rng>(&self, rng: &mut R) -> X

Single draw from the Rv

fn sample<R: Rng>(&self, n: usize, rng: &mut R) -> Vec<X>

Multiple draws of the Rv

fn sample_stream<'r, R: Rng>( &'r self, rng: &'r mut R ) -> Box<dyn Iterator<Item = X> + 'r>

Create a never-ending iterator of samples

impl<Fx> Serialize for Mixture<Fx>

where Fx: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<X, Fx> Support<X> for Mixture<Fx>

where Fx: Rv<X> + Support<X>,

fn supports(&self, x: &X) -> bool

Returns true if x is in the support of the Rv

impl<Fx> TryFrom<Vec<(f64, Fx)>> for Mixture<Fx>

type Error = MixtureError

The type returned in the event of a conversion error.

fn try_from(weighted_components: Vec<(f64, Fx)>) -> Result<Self, Self::Error>

Performs the conversion.

impl<Fx> Variance<f32> for Mixture<Fx>

where Fx: Mean<f32> + Variance<f32>,

fn variance(&self) -> Option<f32>

Returns None if the variance is undefined

impl<Fx> Variance<f64> for Mixture<Fx>

where Fx: Mean<f64> + Variance<f64>,

fn variance(&self) -> Option<f64>

Returns None if the variance is undefined

impl<Fx> StructuralPartialEq for Mixture<Fx>