public void ConstructorTest()
{
int n = 10000;
double[] normal = NormalDistribution.Standard.Generate(n);
double[] uniform = UniformContinuousDistribution.Standard.Generate(n);
double[] poisson = PoissonDistribution.Standard.Generate(n).ToDouble();
double[] gamma = GammaDistribution.Standard.Generate(n);
{
DistributionAnalysis analysis = new DistributionAnalysis(normal);
analysis.Compute();
Assert.AreEqual("Normal", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(uniform);
analysis.Compute();
Assert.AreEqual("UniformContinuous", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(poisson);
analysis.Compute();
Assert.AreEqual("Poisson", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(gamma);
analysis.Compute();
Assert.AreEqual("Gamma", analysis.GoodnessOfFit[0].Name);
}
}
public static ISampleableDistribution <double> FindBestDistribution(double[] samples, bool isBoolean)
{
var analysis = new DistributionAnalysis();
analysis.Learn(samples);
return(analysis.GoodnessOfFit[0].Distribution as ISampleableDistribution <double>);
}
public void ConstructorTest()
{
int n = 10000;
double[] normal = NormalDistribution.Standard.Generate(n);
double[] uniform = UniformContinuousDistribution.Standard.Generate(n);
double[] poisson = PoissonDistribution.Standard.Generate(n).ToDouble();
double[] gamma = GammaDistribution.Standard.Generate(n);
{
DistributionAnalysis analysis = new DistributionAnalysis(normal);
analysis.Compute();
Assert.AreEqual("Normal", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(uniform);
analysis.Compute();
Assert.AreEqual("UniformContinuous", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(poisson);
analysis.Compute();
Assert.AreEqual("Poisson", analysis.GoodnessOfFit[0].Name);
}
{
DistributionAnalysis analysis = new DistributionAnalysis(gamma);
analysis.Compute();
Assert.AreEqual("Gamma", analysis.GoodnessOfFit[0].Name);
}
}
static bool StatisticsAnalyze(double[] list)
{
var analysis = new DistributionAnalysis();
var gof = analysis.Learn(list);
var fit = Enumerable.Select <KeyValuePair <string, GoodnessOfFit>, GoodnessOfFit>(gof, x => x.Value).ToArray();
var first = fit.OrderBy(x => x.ChiSquareRank).FirstOrDefault();
return(first?.Name == "Normal");
}
public void learn1()
{
#region doc_learn
// Let's say we would like to check from which possible
// distribution a given sample might have come from.
double[] x = { -1, 2, 5, 3, 2, 1, 4, 32, 0, 2, 4 };
// Create a distribution analysis
var da = new DistributionAnalysis();
// Learn the analysis
var fit = da.Learn(x);
// Get the most likely distribution amongst the ones that
// have been tried (by default, only a few are tested)
var mostLikely1 = fit[0].Distribution; // N(x; μ = 4.9, σ² = 83.9)
// Sometimes it might be the case that we would like to
// test against some other distributions than the default
// ones. We can add them to the list of tested distributions:
da.Distributions.Add(new VonMisesDistribution(1.0));
// and re-learn the analysis
fit = da.Learn(x);
var mostLikely2 = fit[0].Distribution; // VonMises(x; μ = 1.92, κ = 0.18)
// it is also possible to specify different sample
// weights (but not all distributions support it)
double[] w = { 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0, 0.1, 0.1, 0.1 };
// and re-learn the analysis with weights
fit = da.Learn(x, w);
var mostLikely3 = fit[0].Distribution; // VonMises(x; μ = 2.81, κ = 0.25
#endregion
string expected = (mostLikely1 as IFormattable).ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "N(x; μ = 4.91, σ² = 83.89)");
expected = (mostLikely2 as IFormattable).ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "VonMises(x; μ = 1.92, κ = 0.18)");
expected = (mostLikely3 as IFormattable).ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "VonMises(x; μ = 2.82, κ = 0.25)");
expected = fit[0].ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "VonMises(x; μ = 2.82, κ = 0.25)");
expected = fit[1].ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "Poisson(x; λ = 2.20)");
expected = fit[2].ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "Gumbel(x; μ = 3.04, β = 1.46)");
expected = fit[3].ToString("N2", CultureInfo.InvariantCulture);
Assert.AreEqual(expected, "N(x; μ = 2.20, σ² = 3.51)");
}
/// <summary>
/// Action for the File->Execute command.
/// </summary>
///
public void Estimate_Execute(object sender)
{
Message = String.Empty;
double[] values = Values.Select(x => x.Value).ToArray();
double[] weights = null;
if (IsWeightColumnVisible)
{
weights = Values.Select(x => x.Weight).ToArray();
}
var distribution = Owner.SelectedDistribution;
try
{
distribution.Estimate(values, weights);
}
catch (System.Exception ex)
{
Message += ex.Message + " ";
try
{
distribution.Estimate(values, null);
}
catch (System.Exception ex2)
{
if (ex.Message != ex2.Message)
{
Message += ex2.Message + " ";
}
}
}
var analysis = new DistributionAnalysis(values);
analysis.Compute();
var fit = System.Linq.Enumerable
.Select <KeyValuePair <string, GoodnessOfFit>, GoodnessOfFit>(
analysis.GoodnessOfFit,
x => x.Value).ToArray();
this.Analysis.Clear();
foreach (GoodnessOfFit c in fit.OrderBy(x => x.ChiSquareRank))
{
try { this.Analysis.Add(new GoodnessOfFitViewModel(c)); }
catch { }
}
}
private void FitByAnalysis()
{
for (int i = 0; i < m_dimension; i++)
{
var samples = Samples.Select(x => x[i]).ToArray();
var da = new DistributionAnalysis();
// Learn the analysis
var fit = da.Learn(samples);
var distribution = fit[0].Distribution;
Distributions[i] = distribution;
m_pmax[i] = samples.Select(s => { try { return(distribution.ProbabilityFunction(s)); } catch (Exception) { return(0); } }).Max();
}
}
private void checkDistribution(double[] samples)
{
var analysis = new DistributionAnalysis(samples);
// Compute the analysis
analysis.Compute();
// Get the most likely distribution (first)
var mostLikely = analysis.GoodnessOfFit[0];
// The result should be Poisson(x; lambda = 0.420961)
var result = mostLikely.Distribution.ToString();
}
public void options_test()
{
// Gamma Distribution Fit stalls for some arrays #301
// https://github.com/accord-net/framework/issues/301
double[] x = { 1.003, 1.012, 1.011, 1.057, 1.033, 1.051, 1.045, 1.045, 1.037, 1.059, 1.028, 1.032, 1.029, 1.031, 1.029, 1.023, 1.035 };
DistributionAnalysis analysis = new DistributionAnalysis();
analysis.Options[analysis.GetFirstIndex("GammaDistribution")] = new GammaOptions()
{
Iterations = 0
};
var fit1 = analysis.Learn(x);
Assert.AreEqual("UniformContinuous", analysis.GoodnessOfFit[0].Name);
Assert.AreEqual("Gamma", analysis.GoodnessOfFit[2].Name);
var gamma = analysis.GoodnessOfFit[2].Distribution as GammaDistribution;
Assert.AreEqual(1.0329411764705885, gamma.Mean, 1e-8);
Assert.AreEqual(1.03286759780857, gamma.Median, 1e-8);
Assert.AreEqual(1.0327204376888031, gamma.Mode, 1e-8);
Assert.AreEqual(4530.2415457406223, gamma.Rate, 1e-8);
Assert.AreEqual(4679.4730319532555, gamma.Shape, 1e-8);
analysis.Distributions = new List <IFittableDistribution <double> >()
{
new GammaDistribution()
};
analysis.Options[analysis.GetFirstIndex("GammaDistribution")] = new GammaOptions()
{
Iterations = 1000
};
var fit2 = analysis.Learn(x);
gamma = analysis.GoodnessOfFit[0].Distribution as GammaDistribution;
Assert.AreEqual(1.0329411764705885, gamma.Mean, 1e-8);
Assert.AreEqual(1.03286759780857, gamma.Median, 1e-8);
Assert.AreEqual(1.0327204376888031, gamma.Mode, 1e-8);
Assert.AreEqual(4530.2415515050052, gamma.Rate, 1e-8);
Assert.AreEqual(4679.4730379075245, gamma.Shape, 1e-8);
Assert.AreEqual("Gamma", analysis.GoodnessOfFit[0].Name);
}
public (bool IsNormal, double Max, double Min, double StdDev, double Mean) GetStatisticsResult(double[] data)
{
var analysis = new DistributionAnalysis();
var gof = analysis.Learn(data);
var fit = gof.Select <KeyValuePair <string, GoodnessOfFit>, GoodnessOfFit>(x => x.Value).ToArray();
var isOk = false;
var goFit = fit.OrderBy(x => x.ChiSquareRank).ToArray();
for (int i = 0; i < 5; i++)
{
if (goFit[i]?.Name == "Normal")
{
isOk = true;
}
}
return(isOk, data.Max(), data.Min(), data.StandardDeviation(), data.Mean());
}
public void RankDistribution()
{
// Create a new distribution, such as a Poisson
var poisson = new PoissonDistribution(lambda: 0.42);
// Draw enough samples from it
double[] samples = poisson.Generate(1000000).ToDouble();
// Let's pretend we don't know from which distribution
// those sample come from, and create an analysis object
// to check it for us:
var analysis = new DistributionAnalysis();
// Compute the analysis
var gof = analysis.Learn(samples);
// Get the most likely distribution
var mostLikely = gof[0];
// The result should be Poisson(x; λ = 0.420961)
var result = (mostLikely.Distribution as IFormattable).ToString("N3", CultureInfo.InvariantCulture);
Assert.AreEqual("Poisson(x; λ = 0.422)", result);
}
public void RankDistribution()
{
// Create a new distribution, such as a Poisson
var poisson = new PoissonDistribution(lambda: 0.42);
// Draw enough samples from it
double[] samples = poisson.Generate(1000000).ToDouble();
// Let's pretend we don't know from which distribution
// those sample come from, and create an analysis object
// to check it for us:
var analysis = new DistributionAnalysis(samples);
// Compute the analysis
analysis.Compute();
// Get the most likely distribution
var mostLikely = analysis.GoodnessOfFit[0];
// The result should be Poisson(x; λ = 0.420961)
var result = mostLikely.Distribution.ToString();
Assert.AreEqual("Poisson(x; λ = 0.420961)", result);
}
public void RankDistribution()
{
// Create a new distribution, such as a Poisson
var poisson = new PoissonDistribution(lambda: 0.42);
// Draw enough samples from it
double[] samples = poisson.Generate(1000000).ToDouble();
// Let's pretend we don't know from which distribution
// those sample come from, and create an analysis object
// to check it for us:
var analysis = new DistributionAnalysis(samples);
// Compute the analysis
analysis.Compute();
// Get the most likely distribution
var mostLikely = analysis.GoodnessOfFit[0];
// The result should be Poisson(x; λ = 0.420961)
var result = mostLikely.Distribution.ToString();
Assert.AreEqual("Poisson(x; λ = 0.420961)", result);
}
/// <summary>
/// Action for the File->Execute command.
/// </summary>
///
public void Estimate_Execute(object sender)
{
Message = String.Empty;
double[] values = Values.Select(x => x.Value).ToArray();
double[] weights = null;
if (IsWeightColumnVisible)
weights = Values.Select(x => x.Weight).ToArray();
var distribution = Owner.SelectedDistribution;
try
{
distribution.Estimate(values, weights);
}
catch (System.Exception ex)
{
Message += ex.Message + " ";
try
{
distribution.Estimate(values, null);
}
catch (System.Exception ex2)
{
if (ex.Message != ex2.Message)
Message += ex2.Message + " ";
}
}
var analysis = new DistributionAnalysis(values);
analysis.Compute();
var fit = System.Linq.Enumerable
.Select<KeyValuePair<string, GoodnessOfFit>, GoodnessOfFit>(
analysis.GoodnessOfFit,
x => x.Value).ToArray();
this.Analysis.Clear();
foreach (GoodnessOfFit c in fit.OrderBy(x => x.ChiSquareRank))
{
try { this.Analysis.Add(new GoodnessOfFitViewModel(c)); }
catch { }
}
}
