Struct rv::dist::Mixture

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

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 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<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<Categorical>

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<Poisson>

fn entropy(&self) -> f64

The entropy, H(X)

impl<'_> Entropy for Mixture<&'_ Poisson>

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<&'_ Gaussian>

fn entropy(&self) -> f64

The entropy, H(X)

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<Mixture<Fx>> 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: &Mixture<Fx>) -> bool

This method tests for !=.

impl QuadBounds for Mixture<Gaussian>

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

impl<'_> QuadBounds for Mixture<&'_ Gaussian>

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

impl QuadBounds for Mixture<Poisson>

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

impl<'_> QuadBounds for Mixture<&'_ Poisson>

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

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> StructuralPartialEq for Mixture<Fx>

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> Variance<f32> for Mixture<Fx> where
    Fx: ContinuousDistr<f32> + 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: ContinuousDistr<f64> + Mean<f64> + Variance<f64>, 

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

Returns None if the variance is undefined