distmv

package
v0.11.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 16, 2022 License: BSD-3-Clause Imports: 10 Imported by: 65

Documentation

Overview

Package distmv provides multivariate random distribution types.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NormalLogProb 

func NormalLogProb(x, mu []float64, chol *mat.Cholesky) float64

NormalLogProb computes the log probability of the location x for a Normal distribution the given mean and Cholesky decomposition of the covariance matrix. NormalLogProb panics if len(x) is not equal to len(mu), or if len(mu) != chol.Size().

This function saves time and memory if the Cholesky decomposition is already available. Otherwise, the NewNormal function should be used.

func NormalRand 

func NormalRand(x, mean []float64, chol *mat.Cholesky, src rand.Source) []float64

NormalRand generates a random number with the given mean and Cholesky decomposition of the covariance matrix. If x is nil, new memory is allocated and returned, otherwise the result is stored in place into x. NormalRand panics if x is non-nil and not equal to len(mu), or if len(mu) != chol.Size().

This function saves time and memory if the Cholesky decomposition is already available. Otherwise, the NewNormal function should be used.

Types

type Bhattacharyya 

type Bhattacharyya struct{}

Bhattacharyya is a type for computing the Bhattacharyya distance between probability distributions.

The Bhattacharyya distance is defined as 

D_B = -ln(BC(l,r))
BC = \int_-∞^∞ (p(x)q(x))^(1/2) dx

Where BC is known as the Bhattacharyya coefficient. The Bhattacharyya distance is related to the Hellinger distance by 

H(l,r) = sqrt(1-BC(l,r))

For more information, see 

https://en.wikipedia.org/wiki/Bhattacharyya_distance

func (Bhattacharyya) DistNormal 

func (Bhattacharyya) DistNormal(l, r *Normal) float64

DistNormal computes the Bhattacharyya distance between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

For Normal distributions, the Bhattacharyya distance is 

Σ = (Σ_l + Σ_r)/2
D_B = (1/8)*(μ_l - μ_r)ᵀ*Σ^-1*(μ_l - μ_r) + (1/2)*ln(det(Σ)/(det(Σ_l)*det(Σ_r))^(1/2))

func (Bhattacharyya) DistUniform 

func (Bhattacharyya) DistUniform(l, r *Uniform) float64

DistUniform computes the Bhattacharyya distance between uniform distributions l and r. The dimensions of the input distributions must match or DistUniform will panic.

type CrossEntropy 

type CrossEntropy struct{}

CrossEntropy is a type for computing the cross-entropy between probability distributions.

The cross-entropy is defined as

  • \int_x l(x) log(r(x)) dx = KL(l || r) + H(l)

where KL is the Kullback-Leibler divergence and H is the entropy. For more information, see 

https://en.wikipedia.org/wiki/Cross_entropy

func (CrossEntropy) DistNormal 

func (CrossEntropy) DistNormal(l, r *Normal) float64

DistNormal returns the cross-entropy between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

type Dirichlet 

type Dirichlet struct {
	// contains filtered or unexported fields
}

Dirichlet implements the Dirichlet probability distribution.

The Dirichlet distribution is a continuous probability distribution that generates elements over the probability simplex, i.e. ||x||_1 = 1. The Dirichlet distribution is the conjugate prior to the categorical distribution and the multivariate version of the beta distribution. The probability of a point x is 

1/Beta(α) \prod_i x_i^(α_i - 1)

where Beta(α) is the multivariate Beta function (see the mathext package).

For more information see https://en.wikipedia.org/wiki/Dirichlet_distribution

func NewDirichlet 

func NewDirichlet(alpha []float64, src rand.Source) *Dirichlet

NewDirichlet creates a new dirichlet distribution with the given parameters alpha. NewDirichlet will panic if len(alpha) == 0, or if any alpha is <= 0.

func (*Dirichlet) CovarianceMatrix 

func (d *Dirichlet) CovarianceMatrix(dst *mat.SymDense)

CovarianceMatrix calculates the covariance matrix of the distribution, storing the result in dst. Upon return, the value at element {i, j} of the covariance matrix is equal to the covariance of the i^th and j^th variables. 

covariance(i, j) = E[(x_i - E[x_i])(x_j - E[x_j])]

If the dst matrix is empty it will be resized to the correct dimensions, otherwise dst must match the dimension of the receiver or CovarianceMatrix will panic.

func (*Dirichlet) Dim 

func (d *Dirichlet) Dim() int

Dim returns the dimension of the distribution.

func (*Dirichlet) LogProb 

func (d *Dirichlet) LogProb(x []float64) float64

LogProb computes the log of the pdf of the point x.

It does not check that ||x||_1 = 1.

func (*Dirichlet) Mean 

func (d *Dirichlet) Mean(x []float64) []float64

Mean returns the mean of the probability distribution at x. If the input argument is nil, a new slice will be allocated, otherwise the result will be put in-place into the receiver.

func (*Dirichlet) Prob 

func (d *Dirichlet) Prob(x []float64) float64

Prob computes the value of the probability density function at x.

func (*Dirichlet) Rand 

func (d *Dirichlet) Rand(x []float64) []float64

Rand generates a random number according to the distributon. If the input slice is nil, new memory is allocated, otherwise the result is stored in place.

type Hellinger 

type Hellinger struct{}

Hellinger is a type for computing the Hellinger distance between probability distributions.

The Hellinger distance is defined as 

H^2(l,r) = 1/2 * int_x (\sqrt(l(x)) - \sqrt(r(x)))^2 dx

and is bounded between 0 and 1. Note the above formula defines the squared Hellinger distance, while this returns the Hellinger distance itself. The Hellinger distance is related to the Bhattacharyya distance by 

H^2 = 1 - exp(-D_B)

For more information, see 

https://en.wikipedia.org/wiki/Hellinger_distance

func (Hellinger) DistNormal 

func (Hellinger) DistNormal(l, r *Normal) float64

DistNormal returns the Hellinger distance between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

See the documentation of Bhattacharyya.DistNormal for the formula for Normal distributions.

type KullbackLeibler 

type KullbackLeibler struct{}

KullbackLeibler is a type for computing the Kullback-Leibler divergence from l to r.

The Kullback-Leibler divergence is defined as 

D_KL(l || r ) = \int_x p(x) log(p(x)/q(x)) dx

Note that the Kullback-Leibler divergence is not symmetric with respect to the order of the input arguments.

func (KullbackLeibler) DistDirichlet 

func (KullbackLeibler) DistDirichlet(l, r *Dirichlet) float64

DistDirichlet returns the Kullback-Leibler divergence between Dirichlet distributions l and r. The dimensions of the input distributions must match or DistDirichlet will panic.

For two Dirichlet distributions, the KL divergence is computed as 

D_KL(l || r) = log Γ(α_0_l) - \sum_i log Γ(α_i_l) - log Γ(α_0_r) + \sum_i log Γ(α_i_r)
               + \sum_i (α_i_l - α_i_r)(ψ(α_i_l)- ψ(α_0_l))

Where Γ is the gamma function, ψ is the digamma function, and α_0 is the sum of the Dirichlet parameters.

func (KullbackLeibler) DistNormal 

func (KullbackLeibler) DistNormal(l, r *Normal) float64

DistNormal returns the KullbackLeibler divergence between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

For two normal distributions, the KL divergence is computed as 

D_KL(l || r) = 0.5*[ln(|Σ_r|) - ln(|Σ_l|) + (μ_l - μ_r)ᵀ*Σ_r^-1*(μ_l - μ_r) + tr(Σ_r^-1*Σ_l)-d]

func (KullbackLeibler) DistUniform 

func (KullbackLeibler) DistUniform(l, r *Uniform) float64

DistUniform returns the KullbackLeibler divergence between uniform distributions l and r. The dimensions of the input distributions must match or DistUniform will panic.

type LogProber 

type LogProber interface {
	LogProb(x []float64) float64
}

LogProber computes the log of the probability of the point x.

type Normal 

type Normal struct {
	// contains filtered or unexported fields
}

Normal is a multivariate normal distribution (also known as the multivariate Gaussian distribution). Its pdf in k dimensions is given by 

(2 π)^(-k/2) |Σ|^(-1/2) exp(-1/2 (x-μ)'Σ^-1(x-μ))

where μ is the mean vector and Σ the covariance matrix. Σ must be symmetric and positive definite. Use NewNormal to construct.

func NewNormal 

func NewNormal(mu []float64, sigma mat.Symmetric, src rand.Source) (*Normal, bool)

NewNormal creates a new Normal with the given mean and covariance matrix. NewNormal panics if len(mu) == 0, or if len(mu) != sigma.N. If the covariance matrix is not positive-definite, the returned boolean is false.

func NewNormalChol 

func NewNormalChol(mu []float64, chol *mat.Cholesky, src rand.Source) *Normal

NewNormalChol creates a new Normal distribution with the given mean and covariance matrix represented by its Cholesky decomposition. NewNormalChol panics if len(mu) is not equal to chol.Size().

func NewNormalPrecision 

func NewNormalPrecision(mu []float64, prec *mat.SymDense, src rand.Source) (norm *Normal, ok bool)

NewNormalPrecision creates a new Normal distribution with the given mean and precision matrix (inverse of the covariance matrix). NewNormalPrecision panics if len(mu) is not equal to prec.SymmetricDim(). If the precision matrix is not positive-definite, NewNormalPrecision returns nil for norm and false for ok.

func (*Normal) ConditionNormal 

func (n *Normal) ConditionNormal(observed []int, values []float64, src rand.Source) (*Normal, bool)

ConditionNormal returns the Normal distribution that is the receiver conditioned on the input evidence. The returned multivariate normal has dimension n - len(observed), where n is the dimension of the original receiver. The updated mean and covariance are 

mu = mu_un + sigma_{ob,un}ᵀ * sigma_{ob,ob}^-1 (v - mu_ob)
sigma = sigma_{un,un} - sigma_{ob,un}ᵀ * sigma_{ob,ob}^-1 * sigma_{ob,un}

where mu_un and mu_ob are the original means of the unobserved and observed variables respectively, sigma_{un,un} is the unobserved subset of the covariance matrix, sigma_{ob,ob} is the observed subset of the covariance matrix, and sigma_{un,ob} are the cross terms. The elements of x_2 have been observed with values v. The dimension order is preserved during conditioning, so if the value of dimension 1 is observed, the returned normal represents dimensions {0, 2, ...} of the original Normal distribution.

ConditionNormal returns {nil, false} if there is a failure during the update. Mathematically this is impossible, but can occur with finite precision arithmetic.

func (*Normal) CovarianceMatrix 

func (n *Normal) CovarianceMatrix(dst *mat.SymDense)

CovarianceMatrix stores the covariance matrix of the distribution in dst. Upon return, the value at element {i, j} of the covariance matrix is equal to the covariance of the i^th and j^th variables. 

covariance(i, j) = E[(x_i - E[x_i])(x_j - E[x_j])]

If the dst matrix is empty it will be resized to the correct dimensions, otherwise dst must match the dimension of the receiver or CovarianceMatrix will panic.

func (*Normal) Dim 

func (n *Normal) Dim() int

Dim returns the dimension of the distribution.

func (*Normal) Entropy 

func (n *Normal) Entropy() float64

Entropy returns the differential entropy of the distribution.

func (*Normal) LogProb 

func (n *Normal) LogProb(x []float64) float64

LogProb computes the log of the pdf of the point x.

func (*Normal) MarginalNormal 

func (n *Normal) MarginalNormal(vars []int, src rand.Source) (*Normal, bool)

MarginalNormal returns the marginal distribution of the given input variables. That is, MarginalNormal returns 

p(x_i) = \int_{x_o} p(x_i | x_o) p(x_o) dx_o

where x_i are the dimensions in the input, and x_o are the remaining dimensions. See https://en.wikipedia.org/wiki/Marginal_distribution for more information.

The input src is passed to the call to NewNormal.

func (*Normal) MarginalNormalSingle 

func (n *Normal) MarginalNormalSingle(i int, src rand.Source) distuv.Normal

MarginalNormalSingle returns the marginal of the given input variable. That is, MarginalNormal returns 

p(x_i) = \int_{x_¬i} p(x_i | x_¬i) p(x_¬i) dx_¬i

where i is the input index. See https://en.wikipedia.org/wiki/Marginal_distribution for more information.

The input src is passed to the constructed distuv.Normal.

func (*Normal) Mean 

func (n *Normal) Mean(x []float64) []float64

Mean returns the mean of the probability distribution at x. If the input argument is nil, a new slice will be allocated, otherwise the result will be put in-place into the receiver.

func (*Normal) Prob 

func (n *Normal) Prob(x []float64) float64

Prob computes the value of the probability density function at x.

func (*Normal) Quantile 

func (n *Normal) Quantile(x, p []float64) []float64

Quantile returns the multi-dimensional inverse cumulative distribution function. If x is nil, a new slice will be allocated and returned. If x is non-nil, len(x) must equal len(p) and the quantile will be stored in-place into x. All of the values of p must be between 0 and 1, inclusive, or Quantile will panic.

func (*Normal) Rand 

func (n *Normal) Rand(x []float64) []float64

Rand generates a random number according to the distributon. If the input slice is nil, new memory is allocated, otherwise the result is stored in place.

func (*Normal) ScoreInput 

func (n *Normal) ScoreInput(score, x []float64) []float64

ScoreInput returns the gradient of the log-probability with respect to the input x. That is, ScoreInput computes 

∇_x log(p(x))

If score is nil, a new slice will be allocated and returned. If score is of length the dimension of Normal, then the result will be put in-place into score. If neither of these is true, ScoreInput will panic.

func (*Normal) SetMean 

func (n *Normal) SetMean(mu []float64)

SetMean changes the mean of the normal distribution. SetMean panics if len(mu) does not equal the dimension of the normal distribution.

func (*Normal) TransformNormal 

func (n *Normal) TransformNormal(dst, normal []float64) []float64

TransformNormal transforms the vector, normal, generated from a standard multidimensional normal into a vector that has been generated under the distribution of the receiver.

If dst is non-nil, the result will be stored into dst, otherwise a new slice will be allocated. TransformNormal will panic if the length of normal is not the dimension of the receiver, or if dst is non-nil and len(dist) != len(normal).

type Quantiler 

type Quantiler interface {
	Quantile(x, p []float64) []float64
}

Quantiler returns the multi-dimensional inverse cumulative distribution function. len(x) must equal len(p), and if x is non-nil, len(x) must also equal len(p). If x is nil, a new slice will be allocated and returned, otherwise the quantile will be stored in-place into x. All of the values of p must be between 0 and 1, or Quantile will panic.

type RandLogProber 

type RandLogProber interface {
	Rander
	LogProber
}

RandLogProber is both a Rander and a LogProber.

type Rander 

type Rander interface {
	Rand(x []float64) []float64
}

Rander generates a random number according to the distributon. If the input is non-nil, len(x) must equal len(p) and the dimension of the distribution, otherwise Quantile will panic. If the input is nil, a new slice will be allocated and returned.

type Renyi 

type Renyi struct {
	Alpha float64
}

Renyi is a type for computing the Rényi divergence of order α from l to r.

The Rényi divergence with α > 0, α ≠ 1 is defined as 

D_α(l || r) = 1/(α-1) log(\int_-∞^∞ l(x)^α r(x)^(1-α)dx)

The Rényi divergence has special forms for α = 0 and α = 1. This type does not implement α = ∞. For α = 0, 

D_0(l || r) = -log \int_-∞^∞ r(x)1{p(x)>0} dx

that is, the negative log probability under r(x) that l(x) > 0. When α = 1, the Rényi divergence is equal to the Kullback-Leibler divergence. The Rényi divergence is also equal to half the Bhattacharyya distance when α = 0.5.

The parameter α must be in 0 ≤ α < ∞ or the distance functions will panic.

func (Renyi) DistNormal 

func (renyi Renyi) DistNormal(l, r *Normal) float64

DistNormal returns the Rényi divergence between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

For two normal distributions, the Rényi divergence is computed as 

Σ_α = (1-α) Σ_l + αΣ_r
D_α(l||r) = α/2 * (μ_l - μ_r)'*Σ_α^-1*(μ_l - μ_r) + 1/(2(α-1))*ln(|Σ_λ|/(|Σ_l|^(1-α)*|Σ_r|^α))

For a more nicely formatted version of the formula, see Eq. 15 of 

Kolchinsky, Artemy, and Brendan D. Tracey. "Estimating Mixture Entropy
with Pairwise Distances." arXiv preprint arXiv:1706.02419 (2017).

Note that the this formula is for Chernoff divergence, which differs from Rényi divergence by a factor of 1-α. Also be aware that most sources in the literature report this formula incorrectly.

type StudentsT 

type StudentsT struct {
	// contains filtered or unexported fields
}

StudentsT is a multivariate Student's T distribution. It is a distribution over ℝ^n with the probability density 

p(y) = (Γ((ν+n)/2) / Γ(ν/2)) * (νπ)^(-n/2) * |Ʃ|^(-1/2) *
           (1 + 1/ν * (y-μ)ᵀ * Ʃ^-1 * (y-μ))^(-(ν+n)/2)

where ν is a scalar greater than 2, μ is a vector in ℝ^n, and Ʃ is an n×n symmetric positive definite matrix.

In this distribution, ν sets the spread of the distribution, similar to the degrees of freedom in a univariate Student's T distribution. As ν → ∞, the distribution approaches a multi-variate normal distribution. μ is the mean of the distribution, and the covariance is ν/(ν-2)*Ʃ.

See https://en.wikipedia.org/wiki/Student%27s_t-distribution and http://users.isy.liu.se/en/rt/roth/student.pdf for more information.

func NewStudentsT 

func NewStudentsT(mu []float64, sigma mat.Symmetric, nu float64, src rand.Source) (dist *StudentsT, ok bool)

NewStudentsT creates a new StudentsT with the given nu, mu, and sigma parameters.

NewStudentsT panics if len(mu) == 0, or if len(mu) != sigma.SymmetricDim(). If the covariance matrix is not positive-definite, nil is returned and ok is false.

func (*StudentsT) ConditionStudentsT 

func (s *StudentsT) ConditionStudentsT(observed []int, values []float64, src rand.Source) (dist *StudentsT, ok bool)

ConditionStudentsT returns the Student's T distribution that is the receiver conditioned on the input evidence, and the success of the operation. The returned Student's T has dimension n - len(observed), where n is the dimension of the original receiver. The dimension order is preserved during conditioning, so if the value of dimension 1 is observed, the returned normal represents dimensions {0, 2, ...} of the original Student's T distribution.

ok indicates whether there was a failure during the update. If ok is false the operation failed and dist is not usable. Mathematically this is impossible, but can occur with finite precision arithmetic.

func (*StudentsT) CovarianceMatrix 

func (st *StudentsT) CovarianceMatrix(dst *mat.SymDense)

CovarianceMatrix calculates the covariance matrix of the distribution, storing the result in dst. Upon return, the value at element {i, j} of the covariance matrix is equal to the covariance of the i^th and j^th variables. 

covariance(i, j) = E[(x_i - E[x_i])(x_j - E[x_j])]

If the dst matrix is empty it will be resized to the correct dimensions, otherwise dst must match the dimension of the receiver or CovarianceMatrix will panic.

func (*StudentsT) Dim 

func (s *StudentsT) Dim() int

Dim returns the dimension of the distribution.

func (*StudentsT) LogProb 

func (s *StudentsT) LogProb(y []float64) float64

LogProb computes the log of the pdf of the point x.

func (*StudentsT) MarginalStudentsT 

func (s *StudentsT) MarginalStudentsT(vars []int, src rand.Source) (dist *StudentsT, ok bool)

MarginalStudentsT returns the marginal distribution of the given input variables, and the success of the operation. That is, MarginalStudentsT returns 

p(x_i) = \int_{x_o} p(x_i | x_o) p(x_o) dx_o

where x_i are the dimensions in the input, and x_o are the remaining dimensions. See https://en.wikipedia.org/wiki/Marginal_distribution for more information.

The input src is passed to the created StudentsT.

ok indicates whether there was a failure during the marginalization. If ok is false the operation failed and dist is not usable. Mathematically this is impossible, but can occur with finite precision arithmetic.

func (*StudentsT) MarginalStudentsTSingle 

func (s *StudentsT) MarginalStudentsTSingle(i int, src rand.Source) distuv.StudentsT

MarginalStudentsTSingle returns the marginal distribution of the given input variable. That is, MarginalStudentsTSingle returns 

p(x_i) = \int_{x_o} p(x_i | x_o) p(x_o) dx_o

where i is the input index, and x_o are the remaining dimensions. See https://en.wikipedia.org/wiki/Marginal_distribution for more information.

The input src is passed to the call to NewStudentsT.

func (*StudentsT) Mean 

func (s *StudentsT) Mean(x []float64) []float64

Mean returns the mean of the probability distribution at x. If the input argument is nil, a new slice will be allocated, otherwise the result will be put in-place into the receiver.

func (*StudentsT) Nu 

func (s *StudentsT) Nu() float64

Nu returns the degrees of freedom parameter of the distribution.

func (*StudentsT) Prob 

func (s *StudentsT) Prob(y []float64) float64

Prob computes the value of the probability density function at x.

func (*StudentsT) Rand 

func (s *StudentsT) Rand(x []float64) []float64

Rand generates a random number according to the distributon. If the input slice is nil, new memory is allocated, otherwise the result is stored in place.

type Uniform 

type Uniform struct {
	// contains filtered or unexported fields
}

Uniform represents a multivariate uniform distribution.

func NewUniform 

func NewUniform(bnds []r1.Interval, src rand.Source) *Uniform

NewUniform creates a new uniform distribution with the given bounds.

func NewUnitUniform 

func NewUnitUniform(dim int, src rand.Source) *Uniform

NewUnitUniform creates a new Uniform distribution over the dim-dimensional unit hypercube. That is, a uniform distribution where each dimension has Min = 0 and Max = 1.

func (*Uniform) Bounds 

func (u *Uniform) Bounds(bounds []r1.Interval) []r1.Interval

Bounds returns the bounds on the variables of the distribution. If the input is nil, a new slice is allocated and returned. If the input is non-nil, then the bounds are stored in-place into the input argument, and Bounds will panic if len(bounds) != u.Dim().

func (*Uniform) CDF 

func (u *Uniform) CDF(p, x []float64) []float64

CDF returns the multidimensional cumulative distribution function of the probability distribution at the point x. If p is non-nil, the CDF is stored in-place into the first argument, otherwise a new slice is allocated and returned.

CDF will panic if len(x) is not equal to the dimension of the distribution, or if p is non-nil and len(p) is not equal to the dimension of the distribution.

func (*Uniform) Dim 

func (u *Uniform) Dim() int

Dim returns the dimension of the distribution.

func (*Uniform) Entropy 

func (u *Uniform) Entropy() float64

Entropy returns the differential entropy of the distribution.

func (*Uniform) LogProb 

func (u *Uniform) LogProb(x []float64) float64

LogProb computes the log of the pdf of the point x.

func (*Uniform) Mean 

func (u *Uniform) Mean(x []float64) []float64

Mean returns the mean of the probability distribution at x. If the input argument is nil, a new slice will be allocated, otherwise the result will be put in-place into the receiver.

func (*Uniform) Prob 

func (u *Uniform) Prob(x []float64) float64

Prob computes the value of the probability density function at x.

func (*Uniform) Quantile 

func (u *Uniform) Quantile(x, p []float64) []float64

Quantile returns the multi-dimensional inverse cumulative distribution function. len(x) must equal len(p), and if x is non-nil, len(x) must also equal len(p). If x is nil, a new slice will be allocated and returned, otherwise the quantile will be stored in-place into x. All of the values of p must be between 0 and 1, or Quantile will panic.

func (*Uniform) Rand 

func (u *Uniform) Rand(x []float64) []float64

Rand generates a random number according to the distributon. If the input slice is nil, new memory is allocated, otherwise the result is stored in place.

type Wasserstein 

type Wasserstein struct{}

Wasserstein is a type for computing the Wasserstein distance between two probability distributions.

The Wasserstein distance is defined as 

W(l,r) := inf 𝔼(||X-Y||_2^2)^1/2

For more information, see 

https://en.wikipedia.org/wiki/Wasserstein_metric

func (Wasserstein) DistNormal 

func (Wasserstein) DistNormal(l, r *Normal) float64

DistNormal returns the Wasserstein distance between normal distributions l and r. The dimensions of the input distributions must match or DistNormal will panic.

The Wasserstein distance for Normal distributions is 

d^2 = ||m_l - m_r||_2^2 + Tr(Σ_l + Σ_r - 2(Σ_l^(1/2)*Σ_r*Σ_l^(1/2))^(1/2))

For more information, see 

http://djalil.chafai.net/blog/2010/04/30/wasserstein-distance-between-two-gaussians/

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.