Struct rv::dist::MvGaussian

source ·

pub struct MvGaussian { /* private fields */ }

Expand description

Multivariate Gaussian/Normal Distribution, 𝒩(μ, Σ).

Example

Generate a Wishart random 3x3 matrix Σ ~ W_ν(S)

use nalgebra::{DMatrix, DVector};
use rv::prelude::*;

let k = 3;   // number of dimensions
let df = 6;  // The degrees of freedom is an unsigned int > k

// The scale matrix of the wishar distribution
let scale_mat: DMatrix<f64> = DMatrix::identity(k, k);

// The draw procedure outlined in the appendices of "Bayesian Data
// Analysis" by Andrew Gelman and colleagues.
let mut rng = rand::thread_rng();

// 1. Create a multivariate normal with zero mean and covariance matrix S
let mvg = MvGaussian::new(DVector::zeros(k), scale_mat).unwrap();

// 2. Draw ν (df) vectors {x_1, ..., x_ν}
let xs = mvg.sample(df, &mut rng);

// 3. Compute the sum Σ xx'
let mat = xs
    .iter()
    .fold(DMatrix::<f64>::zeros(k, k), |acc, x: &DVector<f64>| {
        acc +x*x.transpose()
    });

// Check that the matrix is square and has the right size
assert_eq!(mat.nrows(), k);
assert_eq!(mat.ncols(), k);

// check that the matrix is positive definite by attempting a Cholesky
// decomposition.
assert!(mat.cholesky().is_some());

Implementations§

source §

impl MvGaussian

source

pub fn new(mu: DVector<f64>, cov: DMatrix<f64>) -> Result<Self, MvGaussianError>

Create a new multivariate Gaussian distribution

Arguments

mu: k-length mean vector
cov: k-by-k positive-definite covariance matrix

source

pub fn new_cholesky( mu: DVector<f64>, cov_chol: Cholesky<f64, Dyn> ) -> Result<Self, MvGaussianError>

Create a new multivariate Gaussian distribution from Cholesky factorized Dov

Arguments

mu: k-length mean vector
cov_chol: Choleksy decomposition of k-by-k positive-definite covariance matrix

use nalgebra::{DMatrix, DVector};
use rv::prelude::*;

let mu = DVector::zeros(3);
let cov = DMatrix::from_row_slice(3, 3, &[
    2.0, 1.0, 0.0,
    1.0, 2.0, 0.0,
    0.0, 0.0, 1.0
]);

let chol = cov.clone().cholesky().unwrap();
let mvg_r = MvGaussian::new_cholesky(mu, chol);

assert!(mvg_r.is_ok());
let mvg = mvg_r.unwrap();
assert!(cov.relative_eq(mvg.cov(), 1E-8, 1E-8));

source

pub fn new_unchecked(mu: DVector<f64>, cov: DMatrix<f64>) -> Self

Creates a new MvGaussian from mean and covariance without checking whether the parameters are valid.

source

pub fn new_cholesky_unchecked( mu: DVector<f64>, cov_chol: Cholesky<f64, Dyn> ) -> Self

Creates a new MvGaussian from mean and covariance’s Cholesky factorization without checking whether the parameters are valid.

source

pub fn standard(dims: usize) -> Result<Self, MvGaussianError>

Create a standard Gaussian distribution with zero mean and identity covariance matrix.

source

pub fn ndims(&self) -> usize

Get the number of dimensions

Example

let mvg = MvGaussian::standard(4).unwrap();
assert_eq!(mvg.ndims(), 4);

source

pub fn mu(&self) -> &DVector<f64>

Get a reference to the mean

source

pub fn cov(&self) -> &DMatrix<f64>

Get a reference to the covariance

source

pub fn set_mu(&mut self, mu: DVector<f64>) -> Result<(), MvGaussianError>

Set the mean

Example

let mut mvg = MvGaussian::standard(3).unwrap();
let x = DVector::<f64>::zeros(3);

assert::close(mvg.ln_f(&x), -2.756815599614018, 1E-8);

let cov_vals = vec![
    1.01742788,
    0.36586652,
    -0.65620486,
    0.36586652,
    1.00564553,
    -0.42597261,
    -0.65620486,
    -0.42597261,
    1.27247972,
];
let cov: DMatrix<f64> = DMatrix::from_row_slice(3, 3, &cov_vals);
let mu = DVector::<f64>::from_column_slice(&vec![0.5, 3.1, -6.2]);

mvg.set_mu(mu).unwrap();
mvg.set_cov(cov).unwrap();

assert::close(mvg.ln_f(&x), -24.602370253215661, 1E-8);

source

pub fn set_mu_unchecked(&mut self, mu: DVector<f64>)

source

pub fn set_cov(&mut self, cov: DMatrix<f64>) -> Result<(), MvGaussianError>

Set the covariance matrix

Example

let mut mvg = MvGaussian::standard(3).unwrap();
let x = DVector::<f64>::zeros(3);

assert::close(mvg.ln_f(&x), -2.756815599614018, 1E-8);

let cov_vals = vec![
    1.01742788,
    0.36586652,
    -0.65620486,
    0.36586652,
    1.00564553,
    -0.42597261,
    -0.65620486,
    -0.42597261,
    1.27247972,
];
let cov: DMatrix<f64> = DMatrix::from_row_slice(3, 3, &cov_vals);
let mu = DVector::<f64>::from_column_slice(&vec![0.5, 3.1, -6.2]);

mvg.set_mu(mu).unwrap();
mvg.set_cov(cov).unwrap();

assert::close(mvg.ln_f(&x), -24.602370253215661, 1E-8);