/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
///
public override object Clone()
{
var e = new MultivariateEmpiricalDistribution(Dimension);
e.chol = (CholeskyDecomposition)chol.Clone();
e.determinant = determinant;
e.kernel = kernel;
e.numberOfSamples = numberOfSamples;
e.repeats = (int[])repeats.Clone();
e.samples = (double[][])samples.MemberwiseClone();
e.smoothing = smoothing.MemberwiseClone();
e.sumOfWeights = sumOfWeights;
e.type = type;
if (e.weights != null)
{
e.weights = (double[])weights.Clone();
}
if (e.repeats != null)
{
e.repeats = (int[])repeats.Clone();
}
return(e);
}
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
///
public override object Clone()
{
var e = new MultivariateEmpiricalDistribution(Dimension);
e.initialize(kernel, samples.MemberwiseClone(), (double[, ])smoothing.Clone());
return(e);
}
public void ConstructorTest4()
{
// Suppose we have the following data, and we would
// like to estimate a distribution from this data
double[][] samples =
{
new double[] { 0, 1 },
new double[] { 1, 2 },
new double[] { 5, 1 },
new double[] { 7, 1 },
new double[] { 6, 1 },
new double[] { 5, 7 },
new double[] { 2, 1 },
};
// Start by specifying a density kernel
IDensityKernel kernel = new EpanechnikovKernel(dimension: 2);
// Create a multivariate Empirical distribution from the samples
var dist = new MultivariateEmpiricalDistribution(kernel, samples);
// Common measures
double[] mean = dist.Mean; // { 3.71, 2.00 }
double[] median = dist.Median; // { 3.71, 2.00 }
double[] var = dist.Variance; // { 7.23, 5.00 } (diagonal from cov)
double[,] cov = dist.Covariance; // { { 7.23, 0.83 }, { 0.83, 5.00 } }
// Probability mass functions
double pdf1 = dist.ProbabilityDensityFunction(new double[] { 2, 1 }); // 0.039131176997318849
double pdf2 = dist.ProbabilityDensityFunction(new double[] { 4, 2 }); // 0.010212109770266639
double pdf3 = dist.ProbabilityDensityFunction(new double[] { 5, 7 }); // 0.02891906722705221
double lpdf = dist.LogProbabilityDensityFunction(new double[] { 5, 7 }); // -3.5432541357714742
Assert.AreEqual(3.7142857142857144, mean[0]);
Assert.AreEqual(2.0, mean[1]);
Assert.AreEqual(3.7142857142857144, median[0]);
Assert.AreEqual(2.0, median[1]);
Assert.AreEqual(7.2380952380952381, var[0]);
Assert.AreEqual(5.0, var[1]);
Assert.AreEqual(7.2380952380952381, cov[0, 0]);
Assert.AreEqual(0.83333333333333337, cov[0, 1]);
Assert.AreEqual(0.83333333333333337, cov[1, 0]);
Assert.AreEqual(5.0, cov[1, 1]);
Assert.AreEqual(0.039131176997318849, pdf1);
Assert.AreEqual(0.010212109770266639, pdf2);
Assert.AreEqual(0.02891906722705221, pdf3);
Assert.AreEqual(-3.5432541357714742, lpdf);
}
public void WeightedEmpiricalDistribution_DistributionFunction()
{
double[][] samples =
{
new double[] { 5, 2 },
new double[] { 1, 5 },
new double[] { 4, 7 },
new double[] { 1, 6 },
new double[] { 2, 2 },
new double[] { 3, 4 },
new double[] { 4, 8 },
new double[] { 3, 2 },
new double[] { 4, 4 },
new double[] { 3, 7 },
new double[] { 2, 4 },
new double[] { 3, 1 },
};
var target = new MultivariateEmpiricalDistribution(samples);
double[] expected =
{
0.33333333333333331, 0.083333333333333329, 0.83333333333333337,
0.16666666666666666, 0.083333333333333329, 0.41666666666666669,
0.91666666666666663, 0.25, 0.5,
0.66666666666666663, 0.16666666666666666, 0.083333333333333329
};
for (int i = 0; i < samples.Length; i++)
{
double e = expected[i];
double a = target.DistributionFunction(samples[i]);
Assert.AreEqual(e, a);
}
}
public void WeightedEmpiricalDistributionConstructorTest3()
{
double[] weights = { 2, 1, 1, 1, 2, 3, 1, 3, 1, 1, 1, 1 };
double[] samples = { 5, 1, 4, 1, 2, 3, 4, 3, 4, 3, 2, 3 };
weights = weights.Divide(weights.Sum());
var target = new MultivariateEmpiricalDistribution(samples.ToArray(), weights);
Assert.AreEqual(1.2377597081667415, target.Smoothing[0, 0]);
}
public void WeightedEmpiricalDistributionConstructorTest2()
{
double[] original = { 5, 5, 1, 4, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 4, 3, 2, 3 };
var distribution = new MultivariateEmpiricalDistribution(original.ToArray());
double[] weights = { 2, 1, 1, 1, 2, 3, 1, 3, 1, 1, 1, 1 };
double[] source = { 5, 1, 4, 1, 2, 3, 4, 3, 4, 3, 2, 3 };
double[][] samples = source.ToArray();
weights = weights.Divide(weights.Sum());
var target = new MultivariateEmpiricalDistribution(samples,
weights, distribution.Smoothing);
Assert.AreEqual(distribution.Mean[0], target.Mean[0]);
Assert.AreEqual(distribution.Median[0], target.Median[0]);
Assert.AreEqual(distribution.Mode[0], target.Mode[0]);
Assert.AreEqual(distribution.Smoothing[0, 0], target.Smoothing[0, 0]);
Assert.AreEqual(1.3655172413793104, target.Variance[0]);
Assert.AreEqual(target.Weights, weights);
Assert.AreEqual(target.Samples, samples);
for (double x = 0; x < 6; x += 0.1)
{
double actual, expected;
expected = distribution.ComplementaryDistributionFunction(x);
actual = target.ComplementaryDistributionFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
expected = distribution.DistributionFunction(x);
actual = target.DistributionFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
expected = distribution.LogProbabilityDensityFunction(x);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
expected = distribution.ProbabilityDensityFunction(x);
actual = target.ProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual, 1e-15);
}
}
public void GenerateTest1()
{
Accord.Math.Tools.SetupGenerator(0);
double[] mean = { 2, 6 };
double[,] cov =
{
{ 2, 1 },
{ 1, 5 }
};
var normal = new MultivariateNormalDistribution(mean, cov);
double[][] source = normal.Generate(10000000);
var target = new MultivariateEmpiricalDistribution(source);
Assert.IsTrue(mean.IsEqual(target.Mean, 0.001));
Assert.IsTrue(cov.IsEqual(target.Covariance, 0.003));
double[][] samples = target.Generate(10000000);
double[] sampleMean = samples.Mean();
double[,] sampleCov = samples.Covariance();
Assert.AreEqual(2, sampleMean[0], 1e-2);
Assert.AreEqual(6, sampleMean[1], 1e-2);
Assert.AreEqual(2, sampleCov[0, 0], 1e-2);
Assert.AreEqual(1, sampleCov[0, 1], 1e-2);
Assert.AreEqual(1, sampleCov[1, 0], 1e-2);
Assert.AreEqual(5, sampleCov[1, 1], 2e-2);
}
public void FitTest2()
{
double[][] observations =
{
new double[] { 0.1000, -0.2000 },
new double[] { 0.4000, 0.6000 },
new double[] { 2.0000, 0.2000 },
new double[] { 2.0000, 0.3000 }
};
double[] mean = Accord.Statistics.Tools.Mean(observations);
double[,] cov = Accord.Statistics.Tools.Covariance(observations);
var target = new MultivariateEmpiricalDistribution(observations);
target.Fit(observations);
Assert.IsTrue(Matrix.IsEqual(mean, target.Mean));
Assert.IsTrue(Matrix.IsEqual(cov, target.Covariance, 1e-10));
}
public void FitTest()
{
double[][] observations =
{
new double[] { 0.1000, -0.2000 },
new double[] { 0.4000, 0.6000 },
new double[] { 2.0000, 0.2000 },
new double[] { 2.0000, 0.3000 }
};
var target = new MultivariateEmpiricalDistribution(observations);
double[] weigths = { 0.25, 0.25, 0.25, 0.25 };
bool thrown = false;
try
{
target.Fit(observations, weigths);
}
catch (ArgumentException)
{
thrown = true;
}
Assert.IsTrue(thrown);
}
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
///
public override object Clone()
{
var e = new MultivariateEmpiricalDistribution(Dimension);
e.initialize(kernel, samples.MemberwiseClone(), (double[,])smoothing.Clone());
return e;
}