public void ConstructorTest()
{
RayleighDistribution n = new RayleighDistribution(0.807602);
Assert.AreEqual(1.0121790039242726, n.Mean);
Assert.AreEqual(0.27993564482286737, n.Variance);
}
//End of ui.cs file Contents
//-------------------------------------------------------------------------
//Begin of Random.cs file contents
/// <summary>
/// Initializes the random-number generator with a specific seed.
/// </summary>
public void Initialize(uint seed)
{
RandomNumberGenerator = new MT19937Generator(seed);
betaDist = new BetaDistribution(RandomNumberGenerator);
betaPrimeDist = new BetaPrimeDistribution(RandomNumberGenerator);
cauchyDist = new CauchyDistribution(RandomNumberGenerator);
chiDist = new ChiDistribution(RandomNumberGenerator);
chiSquareDist = new ChiSquareDistribution(RandomNumberGenerator);
continuousUniformDist = new ContinuousUniformDistribution(RandomNumberGenerator);
erlangDist = new ErlangDistribution(RandomNumberGenerator);
exponentialDist = new ExponentialDistribution(RandomNumberGenerator);
fisherSnedecorDist = new FisherSnedecorDistribution(RandomNumberGenerator);
fisherTippettDist = new FisherTippettDistribution(RandomNumberGenerator);
gammaDist = new GammaDistribution(RandomNumberGenerator);
laplaceDist = new LaplaceDistribution(RandomNumberGenerator);
lognormalDist = new LognormalDistribution(RandomNumberGenerator);
normalDist = new NormalDistribution(RandomNumberGenerator);
paretoDist = new ParetoDistribution(RandomNumberGenerator);
powerDist = new PowerDistribution(RandomNumberGenerator);
rayleighDist = new RayleighDistribution(RandomNumberGenerator);
studentsTDist = new StudentsTDistribution(RandomNumberGenerator);
triangularDist = new TriangularDistribution(RandomNumberGenerator);
weibullDist = new WeibullDistribution(RandomNumberGenerator);
poissonDist = new PoissonDistribution(RandomNumberGenerator);
// generator.randomGenerator = new MT19937Generator(seed);
}
public void ConstructorTest2()
{
var rayleigh = new RayleighDistribution(sigma: 0.42);
double mean = rayleigh.Mean; // 0.52639193767251
double median = rayleigh.Median; // 0.49451220943852386
double var = rayleigh.Variance; // 0.075711527953380237
double cdf = rayleigh.DistributionFunction(x: 1.4); // 0.99613407986052716
double pdf = rayleigh.ProbabilityDensityFunction(x: 1.4); // 0.030681905868831811
double lpdf = rayleigh.LogProbabilityDensityFunction(x: 1.4); // -3.4840821835248961
double ccdf = rayleigh.ComplementaryDistributionFunction(x: 1.4); // 0.0038659201394728449
double icdf = rayleigh.InverseDistributionFunction(p: cdf); // 1.4000000080222026
double hf = rayleigh.HazardFunction(x: 1.4); // 7.9365079365078612
double chf = rayleigh.CumulativeHazardFunction(x: 1.4); // 5.5555555555555456
string str = rayleigh.ToString(CultureInfo.InvariantCulture); // Rayleigh(x; σ = 0.42)
Assert.AreEqual(0.52639193767251, mean);
Assert.AreEqual(0.49451220943852386, median, 1e-8);
Assert.AreEqual(0.075711527953380237, var);
Assert.AreEqual(5.5555555555555456, chf);
Assert.AreEqual(0.99613407986052716, cdf);
Assert.AreEqual(0.030681905868831811, pdf);
Assert.AreEqual(-3.4840821835248961, lpdf);
Assert.AreEqual(7.9365079365078612, hf);
Assert.AreEqual(0.0038659201394728449, ccdf);
Assert.AreEqual(1.40000000, icdf, 1e-8);
Assert.AreEqual("Rayleigh(x; σ = 0.42)", str);
}
/// <summary>
/// Finds the Rayleigh distribution that best fits the given sample.
/// </summary>
/// <param name="sample">The sample to fit, which must have at least 2 values.</param>
/// <returns>The fit result.</returns>
public static RayleighFitResult FitToRayleigh(this IReadOnlyList <double> sample)
{
if (sample == null)
{
throw new ArgumentNullException(nameof(sample));
}
if (sample.Count < 2)
{
throw new InsufficientDataException();
}
// It's easy to follow maximum likelihood prescription, because there is only one
// parameter and the functional form is fairly simple.
// \ln L = \sum_i p_i = = \sum_i \left[ \ln x_i - 2 \ln \sigma - \frac{1}{2} \frac{x_i^2}{\sigma^2 \right]
// \frac{\partial \ln L}{\partial \sigma} = \sum_i \left[ \frac{x_i^2}{\sigma^3} - \frac{2}{\sigma} \right]
// \frac{\partial^2 \ln L}{\partial \sigma^2} = \sum_i \left[ \frac{2}{\sigma^2} - \frac{3 x_i^2}{\sigma^4} \right]
// Set the first derivative to zero to obtain
// \hat{\sigma}^2 = \frac{1}{2n} \sum_i x_i^2
// \hat{\sigma} = \sqrt{\frac{1}{2} \left< x^2 \right>}
// and plug this value into the second derivative to obtain
// \frac{\partial^2 \ln L}{\partial \sigma^2} = - \frac{4n}{\sigma^2}
// at the minimum, so
// \delta \sigma = \frac{\sigma}{\sqrt{4n}}
// Next consider bias. We know from the moments of the distribution that < x^2 > = 2 \sigma^2, so \hat{\sigma}^2 is
// unbiased. But its square root \hat{\sigma} is not. To get exact distribution of \hat{\sigma},
// x_i \sim Rayleigh(\sigma)
// ( \frac{x_i}{\sigma} )^2 \sim \chi^2(2)
// \sum_i ( \frac{x_i}{\sigma} )^2 \sim \chi^2(2n)
// \left[ \sum_i ( \frac{x_i}{\sigma} )^2 \right]^{1/2} \sim \chi(2n)
// And if z \sim \chi(k) then
// E(z) = \sqrt{2} \frac{\Gamma((k + 1)/2)}{\Gamma(k / 2)}
// V(z) = k - [ E(z) ]^2
// Here k = 2n and our estimator \hat{\sigma} = z / sqrt{2n}, so
// E(\hat{\sigma}) = \frac{\Gamma(n + 1/2)}{\sqrt{n} \Gamma(n)} \sigma = \frac{(n)_{1/2}}{\sqrt{n}} \sigma
// V(\hat{\sigma}) = \left[ 1 - \frac{(n)_{1/2}^2}{n} \right] \sigma^2
// We can use series expansion to verify that
// E(\hat{\sigma}) = \left[ 1 - \frac{1}{8n} + \cdots \right] \sigma
// V(\hat{\sigma}) = \left[ \frac{1}{4n} - \frac{1}{32n^2} + \cdots \right] \sigma^2
// our estimator is asymptotically unbiased and its asymptotic variance agrees with our assessment.
// We correct for the bias of \hat{\sigma} by multiplying by \frac{\sqrt{n}}{(n)_{1/2}}. We could
// correct our variance estimate too, but in order to evaluate the correction at high n,
// we need to do a series expansion, and I regard it as less important that the error estimate
// be exact.
int n = sample.Count;
double s = Math.Sqrt(sample.RawMoment(2) / 2.0) * (Math.Sqrt(n) / AdvancedMath.Pochhammer(n, 1.0 / 2.0));
double ds = s / Math.Sqrt(4.0 * n);
RayleighDistribution distribution = new RayleighDistribution(s);
TestResult test = sample.KolmogorovSmirnovTest(distribution);
return(new RayleighFitResult(new UncertainValue(s, ds), distribution, test));
}
public Rayleigh(double sigma)
{
if (sigma <= 0)
{
throw new ArgumentException("Параметр sigma должен быть больше или равен нуля.");
}
rayleighDistribution = new RayleighDistribution(sigma);
}
public void GenerateTest()
{
Accord.Math.Tools.SetupGenerator(0);
RayleighDistribution target = new RayleighDistribution(2.5);
double[] samples = target.Generate(1000000);
var actual = RayleighDistribution.Estimate(samples);
Assert.AreEqual(2.5, actual.Scale, 1e-3);
}
public void GenerateTest()
{
RayleighDistribution target = new RayleighDistribution(2.5);
double[] samples = target.Generate(1000000);
var actual = RayleighDistribution.Estimate(samples);
//actual.Fit(samples);
Assert.AreEqual(2, actual.Mean, 0.01);
Assert.AreEqual(5, actual.Variance, 0.01);
}
public void ConstructorTest2()
{
var rayleigh = new RayleighDistribution(sigma: 0.42);
double mean = rayleigh.Mean; // 0.52639193767251
double median = rayleigh.Median; // 0.49451220943852386
double var = rayleigh.Variance; // 0.075711527953380237
double mode = rayleigh.Mode; // 0.42
double cdf = rayleigh.DistributionFunction(x: 1.4); // 0.99613407986052716
double pdf = rayleigh.ProbabilityDensityFunction(x: 1.4); // 0.030681905868831811
double lpdf = rayleigh.LogProbabilityDensityFunction(x: 1.4); // -3.4840821835248961
double ccdf = rayleigh.ComplementaryDistributionFunction(x: 1.4); // 0.0038659201394728449
double icdf = rayleigh.InverseDistributionFunction(p: cdf); // 1.4000000080222026
double hf = rayleigh.HazardFunction(x: 1.4); // 7.9365079365078612
double chf = rayleigh.CumulativeHazardFunction(x: 1.4); // 5.5555555555555456
string str = rayleigh.ToString(CultureInfo.InvariantCulture); // Rayleigh(x; σ = 0.42)
Assert.AreEqual(0.52639193767251, mean);
Assert.AreEqual(0.42, mode);
Assert.AreEqual(0.49451220943852386, median, 1e-8);
Assert.AreEqual(0.075711527953380237, var);
Assert.AreEqual(5.5555555555555456, chf);
Assert.AreEqual(0.99613407986052716, cdf);
Assert.AreEqual(0.030681905868831811, pdf);
Assert.AreEqual(-3.4840821835248961, lpdf);
Assert.AreEqual(7.9365079365078612, hf);
Assert.AreEqual(0.0038659201394728449, ccdf);
Assert.AreEqual(1.40000000, icdf, 1e-8);
Assert.AreEqual("Rayleigh(x; σ = 0.42)", str);
var range1 = rayleigh.GetRange(0.95);
Assert.AreEqual(0.13452243301684083, range1.Min);
Assert.AreEqual(1.0280536793538564, range1.Max);
var range2 = rayleigh.GetRange(0.99);
Assert.AreEqual(0.059546263061601511, range2.Min);
Assert.AreEqual(1.2746387879926619, range2.Max);
var range3 = rayleigh.GetRange(0.01);
Assert.AreEqual(0.059546263061601677, range3.Min);
Assert.AreEqual(1.2746387879926619, range3.Max);
}
public void GenerateTest2()
{
Accord.Math.Tools.SetupGenerator(0);
RayleighDistribution target = new RayleighDistribution(4.2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
{
samples[i] = target.Generate();
}
var actual = RayleighDistribution.Estimate(samples);
Assert.AreEqual(4.2, actual.Scale, 1e-3);
}
public void GenerateTest2()
{
RayleighDistribution target = new RayleighDistribution(4.2);
double[] samples = new double[1000000];
for (int i = 0; i < samples.Length; i++)
{
samples[i] = target.Generate();
}
var actual = RayleighDistribution.Estimate(samples);
//actual.Fit(samples);
Assert.AreEqual(4, actual.Mean, 0.01);
Assert.AreEqual(2, actual.Variance, 0.01);
}
public void CumulativeDistributionTest()
{
RayleighDistribution n = new RayleighDistribution(0.807602);
double[] expected = { 0, 0.535415, 0.953414, 0.998992, 0.999995 };
double[] actual = new double[expected.Length];
for (int i = 0; i < actual.Length; i++)
{
actual[i] = n.DistributionFunction(i);
}
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-6);
Assert.IsFalse(double.IsNaN(actual[i]));
}
}
public void TestContinuousDistributions_Rayleigh()
{
TestContinuousDistributionShapeMatchesCumulativeDensity(
new RayleighDistribution(2.0),
0.0,
8.0,
10,
100000,
0.01,
"RayleighDistribution(2.0)");
// Test Parameter Estimation
RayleighDistribution source = new RayleighDistribution(4.0);
RayleighDistribution target = new RayleighDistribution();
target.EstimateDistributionParameters(source.EnumerateDoubles(1000));
Assert.That(target.Sigma, NumericIs.AlmostEqualTo(4.0, 0.1), "Rayleigh Parameter Estimation: Sigma");
}
public void ProbabilityDistributionTest()
{
RayleighDistribution n = new RayleighDistribution(0.807602);
double[] expected = { 0, 0.712311, 0.142855, 0.00463779, 0.0000288872 };
double[] actual = new double[expected.Length];
for (int i = 0; i < actual.Length; i++)
{
actual[i] = n.ProbabilityDensityFunction(i);
}
for (int i = 0; i < actual.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 1e-5);
Assert.IsFalse(double.IsNaN(actual[i]));
}
}
public void TestRayleighDistribution()
{
double[][] para =
{
new double[] { 1.5, 0, 1.137791424661398198866648, 0.379263808220466066288883, 3.671620246021224819564040, 0.081591561022693884879201 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new ContDistTester(para[i], delegate(double a, double b)
{
var ret = new RayleighDistribution
{
Sigma = a
};
return(ret);
}
);
tester.Test(1E-14);
}
}
public void RayleighFit()
{
RayleighDistribution rayleigh = new RayleighDistribution(3.2);
Sample parameter = new Sample();
Sample variance = new Sample();
for (int i = 0; i < 128; i++)
{
// We pick a quite-small sample, because we have a finite-n unbiased estimator.
Sample s = SampleTest.CreateSample(rayleigh, 8, i);
RayleighFitResult r = RayleighDistribution.FitToSample(s);
parameter.Add(r.Scale.Value);
variance.Add(r.Parameters.VarianceOf("Scale"));
Assert.IsTrue(r.GoodnessOfFit.Probability > 0.01);
}
Assert.IsTrue(parameter.PopulationMean.ConfidenceInterval(0.99).ClosedContains(rayleigh.Scale));
Assert.IsTrue(parameter.PopulationVariance.ConfidenceInterval(0.99).ClosedContains(variance.Median));
}
/// <summary>
/// Sets the distribution for operations using the current genrator
/// </summary>
/// <param name="distx">Distx.</param>
public void setDistribution(distributions distx, Dictionary <string, double> args)
{
//TODO check arguments to ensure they are making a change to the distribution
//otherwise throw an exception see laplace as a example of implementing this
switch (distx)
{
case distributions.Bernoili:
BernoulliDistribution x0 = new BernoulliDistribution(gen);
if (args.ContainsKey("alpha"))
{
x0.Alpha = args["alpha"];
}
else
{
throw new System.Exception("for Bernoili distribution you must provide an alpha");
}
dist = x0;
break;
case distributions.Beta:
BetaDistribution x1 = new BetaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x1.Alpha = args["alpha"];
x1.Beta = args["beta"];
}
else
{
throw new System.Exception(" for beta distribution you must provide alpha and beta");
}
dist = x1;
break;
case distributions.BetaPrime:
BetaPrimeDistribution x2 = new BetaPrimeDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x2.Alpha = args["alpha"];
x2.Beta = args["beta"];
}
else
{
throw new System.Exception(" for betaPrime distribution you must provide alpha and beta");
}
dist = x2;
break;
case distributions.Cauchy:
CauchyDistribution x3 = new CauchyDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("gamma"))
{
x3.Alpha = args["alpha"];
x3.Gamma = args["gamma"];
}
else
{
throw new System.Exception("for cauchy dist you must provide alpha and gamma");
}
dist = x3;
break;
case distributions.Chi:
ChiDistribution x4 = new ChiDistribution(gen);
if (args.ContainsKey("alpha"))
{
x4.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chi you must provide alpha");
}
dist = x4;
break;
case distributions.ChiSquared:
ChiSquareDistribution x5 = new ChiSquareDistribution(gen);
if (args.ContainsKey("alpha"))
{
x5.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chiSquared you must provide alpha");
}
dist = x5;
break;
case distributions.ContinuousUniform:
ContinuousUniformDistribution x6 = new ContinuousUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x6.Alpha = args["alpha"];
x6.Beta = args["beta"];
}
else
{
throw new System.Exception("for ContinuousUniform you must provide alpha and beta");
}
dist = x6;
break;
case distributions.DiscreteUniform:
DiscreteUniformDistribution x7 = new DiscreteUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x7.Alpha = (int)args["alpha"];
x7.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for discrete uniform distribution you must provide alpha and beta");
}
dist = x7;
break;
case distributions.Erlang:
ErlangDistribution x8 = new ErlangDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x8.Alpha = (int)args["alpha"];
x8.Lambda = (int)args["lambda"];
}
else
{
throw new System.Exception("for Erlang dist you must provide alpha and lambda");
}
dist = x8;
break;
case distributions.Exponential:
ExponentialDistribution x9 = new ExponentialDistribution(gen);
if (args.ContainsKey("lambda"))
{
x9.Lambda = args["lambda"];
}
else
{
throw new System.Exception("for exponential dist you must provide lambda");
}
dist = x9;
break;
case distributions.FisherSnedecor:
FisherSnedecorDistribution x10 = new FisherSnedecorDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x10.Alpha = (int)args["alpha"];
x10.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for FisherSnedecor you must provide alpha and beta");
}
dist = x10;
break;
case distributions.FisherTippett:
FisherTippettDistribution x11 = new FisherTippettDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
x11.Alpha = args["alpha"];
x11.Mu = args["mu"];
}
else
{
throw new System.Exception("for FisherTippets you must provide alpha and mu");
}
dist = x11;
break;
case distributions.Gamma:
GammaDistribution x12 = new GammaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("theta"))
{
x12.Alpha = args["alpha"];
x12.Theta = args["theta"];
}
else
{
throw new System.Exception("for Gamma dist you must provide alpha and theta");
}
dist = x12;
break;
case distributions.Geometric:
GeometricDistribution x13 = new GeometricDistribution(gen);
if (args.ContainsKey("alpha"))
{
x13.Alpha = args["alpha"];
}
else
{
throw new System.Exception("Geometric distribution requires alpha value");
}
dist = x13;
break;
case distributions.Binomial:
BinomialDistribution x14 = new BinomialDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x14.Alpha = args["alpha"];
x14.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("binomial distribution requires alpha and beta");
}
dist = x14;
break;
case distributions.None:
break;
case distributions.Laplace:
LaplaceDistribution x15 = new LaplaceDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
if (x15.IsValidAlpha(args["alpha"]) && x15.IsValidMu(args["mu"]))
{
x15.Alpha = args["alpha"];
x15.Mu = args["mu"];
}
else
{
throw new ArgumentException("alpha must be greater than zero");
}
}
else
{
throw new System.Exception("Laplace dist requires alpha and mu");
}
dist = x15;
break;
case distributions.LogNormal:
LognormalDistribution x16 = new LognormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x16.Mu = args["mu"];
x16.Sigma = args["sigma"];
}
else
{
throw new System.Exception("lognormal distribution requires mu and sigma");
}
dist = x16;
break;
case distributions.Normal:
NormalDistribution x17 = new NormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x17.Mu = args["mu"];
x17.Sigma = args["sigma"];
}
else
{
throw new System.Exception("normal distribution requires mu and sigma");
}
dist = x17;
break;
case distributions.Pareto:
ParetoDistribution x18 = new ParetoDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x18.Alpha = args["alpha"];
x18.Beta = args["beta"];
}
else
{
throw new System.Exception("pareto distribution requires alpha and beta");
}
dist = x18;
break;
case distributions.Poisson:
PoissonDistribution x19 = new PoissonDistribution(gen);
if (args.ContainsKey("lambda"))
{
x19.Lambda = args["lambda"];
}
else
{
throw new System.Exception("Poisson distribution requires lambda");
}
dist = x19;
break;
case distributions.Power:
PowerDistribution x20 = new PowerDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x20.Alpha = args["alpha"];
x20.Beta = args["beta"];
}
else
{
throw new System.Exception("Power dist requires alpha and beta");
}
dist = x20;
break;
case distributions.RayLeigh:
RayleighDistribution x21 = new RayleighDistribution(gen);
if (args.ContainsKey("sigma"))
{
x21.Sigma = args["sigma"];
}
else
{
throw new System.Exception("Rayleigh dist requires sigma");
}
dist = x21;
break;
case distributions.StudentsT:
StudentsTDistribution x22 = new StudentsTDistribution(gen);
if (args.ContainsKey("nu"))
{
x22.Nu = (int)args["nu"];
}
else
{
throw new System.Exception("StudentsT dist requirres nu");
}
dist = x22;
break;
case distributions.Triangular:
TriangularDistribution x23 = new TriangularDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta") && args.ContainsKey("gamma"))
{
x23.Alpha = args["alpha"];
x23.Beta = args["beta"];
x23.Gamma = args["gamma"];
}
else
{
throw new System.Exception("Triangular distribution requires alpha, beta and gamma");
}
dist = x23;
break;
case distributions.WeiBull:
WeibullDistribution x24 = new WeibullDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x24.Alpha = args["alpha"];
x24.Lambda = args["lambda"];
}
else
{
throw new System.Exception("WeiBull dist requires alpha and lambda");
}
dist = x24;
break;
default:
throw new NotImplementedException("the distribution you want has not yet been implemented " +
"you could help everyone out by going and implementing it");
}
}
public void MedianTest()
{
RayleighDistribution target = new RayleighDistribution(0.52);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
