public void ProbabilityDensityFunctionTest2()
{
double[] mean = new double[64];
double[,] covariance = Accord.Tests.Math.CholeskyDecompositionTest.bigmatrix;
var target = new MultivariateNormalDistribution(mean, covariance);
double expected = double.PositiveInfinity;
double actual = target.ProbabilityDensityFunction(mean);
Assert.AreEqual(expected, actual, 0.00000001);
expected = 1053.6344885618446;
actual = target.LogProbabilityDensityFunction(mean);
Assert.AreEqual(expected, actual, 0.00000001);
double[] x = Matrix.Diagonal(covariance).Multiply(1.5945e7);
expected = 4.781042576287362e-12;
actual = target.ProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-21);
expected = System.Math.Log(4.781042576287362e-12);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-10);
}
public void ConstructorTest4()
{
// Create a multivariate Gaussian distribution
var dist = new MultivariateNormalDistribution(
// mean vector mu
mean: new double[]
{
4, 2
},
// covariance matrix sigma
covariance: new double[, ]
{
{ 0.3, 0.1 },
{ 0.1, 0.7 }
}
);
// Common measures
double[] mean = dist.Mean; // { 4, 2 }
double[] median = dist.Median; // { 4, 2 }
double[] var = dist.Variance; // { 0.3, 0.7 } (diagonal from cov)
double[,] cov = dist.Covariance; // { { 0.3, 0.1 }, { 0.1, 0.7 } }
// Probability mass functions
double pdf1 = dist.ProbabilityDensityFunction(new double[] { 2, 5 });
double pdf2 = dist.ProbabilityDensityFunction(new double[] { 4, 2 });
double pdf3 = dist.ProbabilityDensityFunction(new double[] { 3, 7 });
double lpdf = dist.LogProbabilityDensityFunction(new double[] { 3, 7 });
// Cumulative distribution function (for up to two dimensions)
// compared against R package mnormt: install.packages("mnormt")
// pmnorm(c(3,5), mean=c(4,2), varcov=matrix(c(0.3,0.1,0.1,0.7), 2,2))
double cdf = dist.DistributionFunction(new double[] { 3, 5 });
double ccdf = dist.ComplementaryDistributionFunction(new double[] { 3, 5 });
Assert.AreEqual(4, mean[0]);
Assert.AreEqual(2, mean[1]);
Assert.AreEqual(4, median[0]);
Assert.AreEqual(2, median[1]);
Assert.AreEqual(0.3, var[0]);
Assert.AreEqual(0.7, var[1]);
Assert.AreEqual(0.3, cov[0, 0]);
Assert.AreEqual(0.1, cov[0, 1]);
Assert.AreEqual(0.1, cov[1, 0]);
Assert.AreEqual(0.7, cov[1, 1]);
Assert.AreEqual(0.000000018917884164743237, pdf1);
Assert.AreEqual(0.35588127170858852, pdf2);
Assert.AreEqual(0.000000000036520107734505265, pdf3);
Assert.AreEqual(-24.033158110192296, lpdf);
Assert.AreEqual(0.033944035782101548, cdf);
}
private static void checkDegenerate(MultivariateNormalDistribution target)
{
Assert.AreEqual(1, target.Mean[0]);
Assert.AreEqual(2, target.Mean[1]);
Assert.AreEqual(0, target.Covariance[0, 0]);
Assert.AreEqual(0, target.Covariance[0, 1]);
Assert.AreEqual(0, target.Covariance[1, 0]);
Assert.AreEqual(0, target.Covariance[1, 1]);
// Common measures
double[] mean = target.Mean; // { 1, 2 }
double[] median = target.Median; // { 4, 2 }
double[] var = target.Variance; // { 0.0, 0.0 } (diagonal from cov)
double[,] cov = target.Covariance; // { { 0.0, 0.0 }, { 0.0, 0.0 } }
// Probability mass functions
double pdf1 = target.ProbabilityDensityFunction(new double[] { 1, 2 });
double pdf2 = target.ProbabilityDensityFunction(new double[] { 4, 2 });
double pdf3 = target.ProbabilityDensityFunction(new double[] { 3, 7 });
double lpdf = target.LogProbabilityDensityFunction(new double[] { 3, 7 });
// Cumulative distribution function (for up to two dimensions)
double cdf1 = target.DistributionFunction(new double[] { 1, 2 });
double cdf2 = target.DistributionFunction(new double[] { 3, 5 });
double ccdf1 = target.ComplementaryDistributionFunction(new double[] { 1, 2 });
double ccdf2 = target.ComplementaryDistributionFunction(new double[] { 3, 5 });
Assert.AreEqual(1, mean[0]);
Assert.AreEqual(2, mean[1]);
Assert.AreEqual(1, median[0]);
Assert.AreEqual(2, median[1]);
Assert.AreEqual(0.0, var[0]);
Assert.AreEqual(0.0, var[1]);
Assert.AreEqual(0.0, cov[0, 0]);
Assert.AreEqual(0.0, cov[0, 1]);
Assert.AreEqual(0.0, cov[1, 0]);
Assert.AreEqual(0.0, cov[1, 1]);
Assert.AreEqual(0.15915494309189532, pdf1);
Assert.AreEqual(0.15915494309189532, pdf2);
Assert.AreEqual(0.15915494309189532, pdf3);
Assert.AreEqual(-1.8378770664093456, lpdf);
Assert.AreEqual(1.0, cdf1);
Assert.AreEqual(0.0, cdf2);
Assert.AreEqual(0.0, ccdf1);
Assert.AreEqual(1.0, ccdf2);
}
public void CumulativeFunctionTest2()
{
double[] mean = { 4.2 };
double[,] covariance = { { 1.4 } };
var baseline = new NormalDistribution(4.2, System.Math.Sqrt(covariance[0, 0]));
var target = new MultivariateNormalDistribution(mean, covariance);
for (int i = 0; i < 10; i++)
{
double x = (i - 2) / 10.0;
{
double actual = target.ProbabilityDensityFunction(x);
double expected = baseline.ProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-10);
}
{
double actual = target.DistributionFunction(x);
double expected = baseline.DistributionFunction(x);
Assert.AreEqual(expected, actual);
}
{
double actual = target.ComplementaryDistributionFunction(x);
double expected = baseline.ComplementaryDistributionFunction(x);
Assert.AreEqual(expected, actual);
}
}
}
public void FitTest3()
{
double[][] observations =
{
new double[] { 1, 2 },
new double[] { 2, 4 },
new double[] { 3, 6 },
new double[] { 4, 8 }
};
var target = new MultivariateNormalDistribution(2);
NormalOptions options = new NormalOptions()
{
Robust = true
};
target.Fit(observations, options);
double pdf = target.ProbabilityDensityFunction(4, 2);
double cdf = target.DistributionFunction(4, 2);
bool psd = target.Covariance.IsPositiveDefinite();
Assert.AreEqual(0.043239154739844896, pdf);
Assert.AreEqual(0.12263905840338646, cdf);
Assert.IsFalse(psd);
}
public void CumulativeFunctionTest1()
{
// Comparison against dmvnorm from the mvtnorm R package
double[] mean = { 1, -1 };
double[,] covariance =
{
{ 0.9, 0.4 },
{ 0.4, 0.3 },
};
var target = new MultivariateNormalDistribution(mean, covariance);
double[] x = { 1.2, -0.8 };
// dmvnorm(x=c(1.2, -0.8), mean=c(1, -1), sigma=matrix(c(0.9, 0.4, 0.4, 0.3), 2, 2))
double pdf = target.ProbabilityDensityFunction(x);
// pmvnorm(upper=c(1.2, -0.8), mean=c(1, -1), sigma=matrix(c(0.9, 0.4, 0.4, 0.3), 2, 2))
double cdf = target.DistributionFunction(x);
// pmvnorm(lower=c(1.2, -0.8), mean=c(1, -1), sigma=matrix(c(0.9, 0.4, 0.4, 0.3), 2, 2))
double ccdf = target.ComplementaryDistributionFunction(x);
Assert.AreEqual(0.44620942136345987, pdf);
Assert.AreEqual(0.5049523013014460826, cdf, 1e-10);
Assert.AreEqual(0.27896707550525140507, ccdf, 1e-10);
}
/// <summary>
/// Calculates Renyi's quadratic entropy of a particle set (also used for JPDAF).
/// </summary>
/// <param name="particles">particle filter.</param>
/// <param name="stateSelector">Particle state selector function (e.g. [x, y, vX, vY]).</param>
/// <returns>Renyi's quadratic entropy of a particle set.</returns>
public static double CalculateEntropy <TParticle>(this IEnumerable <TParticle> particles, Func <TParticle, double[]> stateSelector)
where TParticle : class, IParticle
{
var nParticles = particles.Count();
/***************** kernel function calculation ******************/
var dKrnl = 4;
var eKrnl = 1 / (4 + dKrnl);
var hKrnl = System.Math.Pow(4 / (dKrnl + 2), eKrnl) * System.Math.Pow(nParticles, -eKrnl); //scaling param
var states = particles.Select(x => stateSelector(x)).ToList();
var kernel = states.ToMatrix().Covariance().Multiply(System.Math.Pow(hKrnl, dKrnl)); //particle filter kernel
/***************** kernel function calculation ******************/
var mean = new double[kernel.ColumnCount()];
var normalDistribution = new MultivariateNormalDistribution(mean, kernel.Multiply(2));
var entropy = 0d;
for (int i = 0; i < nParticles; i++)
{
for (int j = 0; j < nParticles; j++)
{
var stateDiff = states[i].Subtract(states[j]);
var kernelVal = normalDistribution.ProbabilityDensityFunction(stateDiff);
entropy += kernelVal;
}
}
entropy = -System.Math.Log10(entropy / (nParticles * nParticles));
return(entropy);
}
public void ConstructorTest4()
{
// Create a multivariate Gaussian distribution
var dist = new MultivariateNormalDistribution(
// mean vector mu
mean: new double[]
{
4, 2
},
// covariance matrix sigma
covariance: new double[, ]
{
{ 0.3, 0.1 },
{ 0.1, 0.7 }
}
);
// Common measures
double[] mean = dist.Mean; // { 4, 2 }
double[] median = dist.Median; // { 4, 2 }
double[] var = dist.Variance; // { 0.3, 0.7 } (diagonal from cov)
double[,] cov = dist.Covariance; // { { 0.3, 0.1 }, { 0.1, 0.7 } }
// Probability mass functions
double pdf1 = dist.ProbabilityDensityFunction(new double[] { 2, 5 }); // 0.000000018917884164743237
double pdf2 = dist.ProbabilityDensityFunction(new double[] { 4, 2 }); // 0.35588127170858852
double pdf3 = dist.ProbabilityDensityFunction(new double[] { 3, 7 }); // 0.000000000036520107734505265
double lpdf = dist.LogProbabilityDensityFunction(new double[] { 3, 7 }); // -24.033158110192296
Assert.AreEqual(4, mean[0]);
Assert.AreEqual(2, mean[1]);
Assert.AreEqual(4, median[0]);
Assert.AreEqual(2, median[1]);
Assert.AreEqual(0.3, var[0]);
Assert.AreEqual(0.7, var[1]);
Assert.AreEqual(0.3, cov[0, 0]);
Assert.AreEqual(0.1, cov[0, 1]);
Assert.AreEqual(0.1, cov[1, 0]);
Assert.AreEqual(0.7, cov[1, 1]);
Assert.AreEqual(0.000000018917884164743237, pdf1);
Assert.AreEqual(0.35588127170858852, pdf2);
Assert.AreEqual(0.000000000036520107734505265, pdf3);
Assert.AreEqual(-24.033158110192296, lpdf);
}
public void ProbabilityFunctionTest4()
{
// https://code.google.com/p/accord/issues/detail?id=98
/*
* mean = c(0.25, 0.082)
* sigma = matrix(c(0.0117, 0.0032}, 0.0032, 0.001062), 2, 2)
*
* d = seq(0.03, 0.13, 0.0001)
* n <- length(d)
* r <- rep(0, n)
*
* for (i in 1:n) {
* r[i] = dmnorm(c(0.25, d[i]), mean, sigma)
* }
*/
var target = new MultivariateNormalDistribution(
new[] { 0.25, 0.082 },
new[, ] {
{ 0.0117, 0.0032 }, { 0.0032, 0.001062 }
});
double[] vec = { 0.25, -1d };
double[] d = Matrix.Vector(0.03, 0.13, 0.01);
double[] actual = new double[d.Length];
double[] expected =
{
0.07736363146686682512598, 0.95791683037271524447931, 6.94400533773376249513376,
29.47023331179536498325433, 73.22314665629953367442795, 106.51345886810220520146686,
90.70931216253406148553040, 45.22624649290145271152142, 13.20141558295499173425469,
2.25601377127287250345944, 0.22571180597171525139544, 0.2257118059717152513954
};
for (int i = 0; i < d.Length; i++)
{
vec[1] = d[i];
actual[i] = target.ProbabilityDensityFunction(vec);
}
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-12);
}
for (int i = 0; i < d.Length; i++)
{
vec[1] = d[i];
actual[i] = System.Math.Exp(target.LogProbabilityDensityFunction(vec));
}
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-12);
}
}
private static double[, ][] calculateZXMatrix <TFilter, TState, TMeasurement>(this IList <TFilter> kalmanFilters,
IList <TMeasurement> measurements,
out double[,] probsZX)
where TFilter : KalmanFilter <TState, TMeasurement>
{
probsZX = new double[measurements.Count, kalmanFilters.Count];
var innovZX = new double[measurements.Count, kalmanFilters.Count][];
for (int tIdx = 0; tIdx < kalmanFilters.Count; tIdx++)
{
var kalman = kalmanFilters[tIdx];
var zeroCoordinate = new double[kalman.MeasurementVectorDimension];
var mvnPDF = new MultivariateNormalDistribution(zeroCoordinate, kalman.ResidualCovariance);
var mulCorrectionFactor = (double)1 / mvnPDF.ProbabilityDensityFunction(zeroCoordinate);
for (int mIdx = 0; mIdx < measurements.Count; mIdx++)
{
var measurement = measurements[mIdx];
//delta' / S^-1 * delta; this expression has ChiSquare distribution (Mahalanobis distance)
double[] delta; double mahalanobisDistancce;//not used
var isInsideGate = kalman.IsMeasurementInsideGate(measurement, out delta, out mahalanobisDistancce);
innovZX[mIdx, tIdx] = delta;
if (isInsideGate)
{
probsZX[mIdx, tIdx] = mvnPDF.ProbabilityDensityFunction(delta) * mulCorrectionFactor; //modification (added mul correction factor)
}
//else probsZX[mIdx, tIdx] = 0 (by default)
}
}
return(innovZX);
}
private static double[, ][] calculateZXMatrix <TFilter, TState, TMeasurement>(this IList <TFilter> kalmanFilters,
IList <TMeasurement> measurements,
out double[,] probsZX)
where TFilter : KalmanFilter <TState, TMeasurement>
{
probsZX = new double[measurements.Count, kalmanFilters.Count];
var innovZX = new double[measurements.Count, kalmanFilters.Count][];
for (int tIdx = 0; tIdx < kalmanFilters.Count; tIdx++)
{
var kalman = kalmanFilters[tIdx];
var zeroCoordinate = new double[kalman.MeasurementVectorDimension];
var mvnPDF = new MultivariateNormalDistribution(zeroCoordinate, kalman.CovarianceMatrix);
var mulCorrectionFactor = (double)1 / mvnPDF.ProbabilityDensityFunction(zeroCoordinate);
for (int mIdx = 0; mIdx < measurements.Count; mIdx++)
{
var measurement = measurements[mIdx];
var delta = kalman.CalculatePredictionError(measurement);
innovZX[mIdx, tIdx] = delta;
//delta' / S^-1 * delta; this expression has ChiSquare distribution
var gate = delta.Multiply(kalman.CovarianceMatrixInv).Multiply(delta.Transpose()).Sum();
if (gate < gateThreshold)
{
probsZX[mIdx, tIdx] = mvnPDF.ProbabilityDensityFunction(delta) * mulCorrectionFactor; //modification (added mul correction factor)
}
//else probsZX[mIdx, tIdx] = 0 (by default)
}
}
return(innovZX);
}
public void TestNormalDistribution2Dimensions4()
{
double[] mean = { 0, 0 };
double[,] covarianceMatrix =
{
{ 1.1, 1 },
{ 1, 1 }
};
double[] value = { 0.1, 0.1 };
MultivariateNormalDistribution mnd = new MultivariateNormalDistribution(mean, covarianceMatrix);
double expected = mnd.ProbabilityDensityFunction(value);
double actual = MathHelper.GaussianDistribution(mean, covarianceMatrix, value);
Assert.IsTrue(Math.Abs(expected - actual) < eps);
}
public void TestNormalDistribution2Dimensions2()
{
double[] mean = { -0.5, 9.0 };
double[,] covarianceMatrix =
{
{ 10.4, 7.9 },
{ 1.0, 17.4 }
};
double[] value = { -5.5, 4.0 };
MultivariateNormalDistribution mnd = new MultivariateNormalDistribution(mean, covarianceMatrix);
double expected = mnd.ProbabilityDensityFunction(value);
double actual = MathHelper.GaussianDistribution(mean, covarianceMatrix, value);
Assert.IsTrue(Math.Abs(expected - actual) < eps);
}
public void ProbabilityDensityFunctionTest()
{
double[] mean = { 1, -1 };
double[,] covariance =
{
{ 0.9, 0.4 },
{ 0.4, 0.3 },
};
var target = new MultivariateNormalDistribution(mean, covariance);
double[] x = { 1.2, -0.8 };
double expected = 0.446209421363460;
double actual = target.ProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 0.00000001);
}
public void ToMultivariateTest()
{
double x = 3;
double mean = 7;
double dev = 5;
NormalDistribution target = new NormalDistribution(mean, dev);
MultivariateNormalDistribution multi =
target.ToMultivariateDistribution();
Assert.AreEqual(target.Mean, multi.Mean[0]);
Assert.AreEqual(target.Variance, multi.Covariance[0, 0]);
Assert.AreEqual(target.Variance, multi.Variance[0]);
double expected = 0.0579383105522966;
double actual = multi.ProbabilityDensityFunction(x);
Assert.IsFalse(double.IsNaN(actual));
Assert.AreEqual(expected, actual, 1e-15);
}
public void ProbabilityDensityFunctionTest3()
{
double[] mean = new double[3];
double[,] covariance = Matrix.Identity(3);
var target = new MultivariateNormalDistribution(mean, covariance);
double[] x = { 1.2, -0.8 };
bool thrown = false;
try
{
target.ProbabilityDensityFunction(x);
}
catch (DimensionMismatchException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
public void ConstructorTest1()
{
NormalDistribution normal = new NormalDistribution(4.2, 1.2);
MultivariateNormalDistribution target = new MultivariateNormalDistribution(new[] { 4.2 }, new[, ] {
{ 1.2 * 1.2 }
});
double[] mean = target.Mean;
double[] median = target.Median;
double[] var = target.Variance;
double[,] cov = target.Covariance;
double apdf1 = target.ProbabilityDensityFunction(new double[] { 2 });
double apdf2 = target.ProbabilityDensityFunction(new double[] { 4 });
double apdf3 = target.ProbabilityDensityFunction(new double[] { 3 });
double alpdf = target.LogProbabilityDensityFunction(new double[] { 3 });
double acdf = target.DistributionFunction(new double[] { 3 });
double accdf = target.ComplementaryDistributionFunction(new double[] { 3 });
double epdf1 = target.ProbabilityDensityFunction(new double[] { 2 });
double epdf2 = target.ProbabilityDensityFunction(new double[] { 4 });
double epdf3 = target.ProbabilityDensityFunction(new double[] { 3 });
double elpdf = target.LogProbabilityDensityFunction(new double[] { 3 });
double ecdf = target.DistributionFunction(new double[] { 3 });
double eccdf = target.ComplementaryDistributionFunction(new double[] { 3 });
Assert.AreEqual(normal.Mean, target.Mean[0]);
Assert.AreEqual(normal.Median, target.Median[0]);
Assert.AreEqual(normal.Variance, target.Variance[0]);
Assert.AreEqual(normal.Variance, target.Covariance[0, 0]);
Assert.AreEqual(epdf1, apdf1);
Assert.AreEqual(epdf2, apdf2);
Assert.AreEqual(epdf3, apdf3);
Assert.AreEqual(elpdf, alpdf);
Assert.AreEqual(ecdf, acdf);
Assert.AreEqual(eccdf, accdf);
Assert.AreEqual(1.0 - ecdf, eccdf);
}
public double evaluate(double[] x)
{
return(probModel.ProbabilityDensityFunction(x));
}
