public void ConstructorTest11()
{
var original = new ChiSquareDistribution(degreesOfFreedom: 7);
var chisq = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
testChiSquare(chisq);
}
/// <summary>
/// Gets the spatial representation of the error covariance.
/// </summary>
/// <param name="positionSelector">Position selector function.</param>
/// <param name="confidence">
/// Confidence for the Chi-square distribution.
/// H * P * H' has the Chi-square distribution where H is measurement matrix and P is error covariance matrix.
/// </param>
/// <param name="positionSelectionMatrix">Measurement matrix which selects state position. If null the state measurement matrix will be used.</param>
/// <returns>2D representation of the error covariance.</returns>
public Ellipse GetEllipse(Func <TState, PointF> positionSelector, double confidence = 0.99, double[,] positionSelectionMatrix = null)
{
positionSelectionMatrix = positionSelectionMatrix ?? this.MeasurementMatrix;
var measurementErrorCov = positionSelectionMatrix.Multiply(this.ErrorCovariance).Multiply(positionSelectionMatrix.Transpose());
var chiSquare = new ChiSquareDistribution(2).InverseDistributionFunction(confidence);
var cov = measurementErrorCov.Multiply(chiSquare);
var ellipse = Ellipse.Fit(cov);
ellipse.Center = positionSelector(this.State);
return(ellipse);
}
public void InverseCumulativeFunctionTest()
{
double a;
var target = new ChiSquareDistribution();
a = target.InverseDistributionFunction(0);
Assert.AreEqual(0.0, a, 1e-5);
Assert.IsFalse(double.IsNaN(a));
a = target.InverseDistributionFunction(1);
Assert.AreEqual(double.PositiveInfinity, a, 1e-5);
Assert.IsFalse(double.IsNaN(a));
}
/// <summary>
/// Construct a Chi-Square Test.
/// </summary>
/// <param name="expected">The expected variable values.</param>
/// <param name="observed">The observed variable values.</param>
/// <param name="degreesOfFreedom">The chi-square distribution degrees of freedom.</param>
/// <param name="threshold">The significance threshold. By default, 0.05 will be used.</param>
public ChiSquareTest(double[] expected, double[] observed, int degreesOfFreedom, double threshold)
{
if (expected == null)
{
throw new ArgumentNullException("expected");
}
if (observed == null)
{
throw new ArgumentNullException("observed");
}
this.Threshold = threshold;
this.distribution = new ChiSquareDistribution(degreesOfFreedom);
this.compute(expected, observed);
}
public void ConstructorTest()
{
var chisq = new ChiSquareDistribution(degreesOfFreedom: 7);
double mean = chisq.Mean; // 7
double median = chisq.Median; // 6.345811195595612
double var = chisq.Variance; // 14
double mode = chisq.Mode; // 5.0
double cdf = chisq.DistributionFunction(x: 6.27); // 0.49139966433823956
double pdf = chisq.ProbabilityDensityFunction(x: 6.27); // 0.11388708001184455
double lpdf = chisq.LogProbabilityDensityFunction(x: 6.27); // -2.1725478476948092
double ccdf = chisq.ComplementaryDistributionFunction(x: 6.27); // 0.50860033566176044
double icdf = chisq.InverseDistributionFunction(p: cdf); // 6.2700000000852318
double hf = chisq.HazardFunction(x: 6.27); // 0.22392254197721179
double chf = chisq.CumulativeHazardFunction(x: 6.27); // 0.67609276602233315
string str = chisq.ToString(); // "χ²(x; df = 7)
Assert.AreEqual(7, mean);
Assert.AreEqual(6.345811195595612, median, 1e-6);
Assert.AreEqual(14, var);
Assert.AreEqual(5.0, mode);
Assert.AreEqual(0.67609276602233315, chf);
Assert.AreEqual(0.49139966433823956, cdf);
Assert.AreEqual(0.11388708001184455, pdf);
Assert.AreEqual(-2.1725478476948092, lpdf);
Assert.AreEqual(0.22392254197721179, hf);
Assert.AreEqual(0.50860033566176044, ccdf);
Assert.AreEqual(6.2700000000852318, icdf, 1e-6);
Assert.AreEqual("χ²(x; df = 7)", str);
var range1 = chisq.GetRange(0.95);
var range2 = chisq.GetRange(0.99);
var range3 = chisq.GetRange(0.01);
Assert.AreEqual(2.1673499092980579, range1.Min);
Assert.AreEqual(14.067140449340167, range1.Max);
Assert.AreEqual(1.2390423055679316, range2.Min);
Assert.AreEqual(18.475306906582361, range2.Max);
Assert.AreEqual(1.2390423055679316, range3.Min);
Assert.AreEqual(18.475306906582361, range3.Max);
}
public void ConstructorTest11()
{
var original = new ChiSquareDistribution(degreesOfFreedom: 7);
var chisq = GeneralContinuousDistribution.FromDensityFunction(
original.Support, original.ProbabilityDensityFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.DistributionFunction(i);
double actual = chisq.DistributionFunction(i);
Assert.IsTrue(expected.IsRelativelyEqual(actual, 1e-5));
Assert.IsFalse(Double.IsNaN(actual));
Assert.IsFalse(Double.IsNaN(expected));
}
testChiSquare(chisq);
}
public void ConstructorTest10()
{
var original = new ChiSquareDistribution(degreesOfFreedom: 7);
var chisq = GeneralContinuousDistribution.FromDistributionFunction(
original.Support, original.DistributionFunction);
for (double i = -10; i < +10; i += 0.1)
{
double expected = original.ProbabilityDensityFunction(i);
double actual = chisq.ProbabilityDensityFunction(i);
double diff = Math.Abs(expected - actual);
Assert.AreEqual(expected, actual, 1e-8);
Assert.IsFalse(Double.IsNaN(actual));
Assert.IsFalse(Double.IsNaN(expected));
}
testChiSquare(chisq);
}
public void TestChiSquareDistribution()
{
double[][] para =
{
new double[] { 7, 0, 4.254852183546515743793886, 0.1183315591713442321707384, 14.06714044934016874262697, 0.0174057454954412176379300 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new ContDistTester(para[i], delegate(double a, double b)
{
var ret = new ChiSquareDistribution
{
Alpha = (int)a
};
return(ret);
}
);
tester.Test(1E-14);
}
}
public void DistributionFunctionTest()
{
int degreesOfFreedom;
double actual, expected, x;
ChiSquareDistribution target;
degreesOfFreedom = 1;
target = new ChiSquareDistribution(degreesOfFreedom);
x = 5;
actual = target.DistributionFunction(x);
expected = 0.9747;
Assert.AreEqual(expected, actual, 1e-4);
degreesOfFreedom = 5;
target = new ChiSquareDistribution(degreesOfFreedom);
x = 5;
actual = target.DistributionFunction(x);
expected = 0.5841;
Assert.AreEqual(expected, actual, 1e-4);
}
public void MedianTest()
{
var target = new ChiSquareDistribution(degreesOfFreedom: 4);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
private double CalculateThreshold(double quantile) => Math.Sqrt(ChiSquareDistribution.Inverse(quantile, Dimensions));
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ChiSquareDistribution obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
/// <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");
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ChiSquareDistribution obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
/// <summary>
/// Shows a new chart in a default form.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function, numInterpolatedValues ) );
/// </code>
/// </remarks>
public static void Show( ChiSquareDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
Show( ToChart( dist, function, numInterpolatedValues ) );
}
/// <summary>
/// Updates the given chart with the specified distribution.
/// </summary>
/// <param name="chart">A chart.</param>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
/// <remarks>
/// Plots the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// <br/>
/// Titles are added only if chart does not currently contain any titles.
/// <br/>
/// chart.Series[0] is replaced, or added if necessary.
/// </remarks>
public static void Update( ref ChartControl chart, ChiSquareDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
List<string> titles = new List<string>()
{
"ChiSquareDistribution",
String.Format("df={0}", dist.DegreesOfFreedom)
};
UpdateContinuousDistribution( ref chart, dist, titles, function, numInterpolatedValues );
}
/// <summary>
/// Returns a new line chart plotting the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <param name="numInterpolatedValues">The number of interpolated values.</param>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( ChiSquareDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function, numInterpolatedValues );
return chart;
}
public Graph RunIteration()
{
var infectionNodes = networkNodes[_currentNetworkKey];
var rand = new Random(DateTime.Now.Millisecond);
var previousStates = new Dictionary <string, InfectionNode>();
foreach (var key in infectionNodes.Keys)
{
previousStates[key] = new InfectionNode(infectionNodes[key]);
}
foreach (var nodeKey in infectionNodes.Keys)
{
if (infectionNodes[nodeKey].NodeStatus == NodeStatus.Removed)
{
MakeSuceptibleNode(nodeKey);
}
if (infectionNodes[nodeKey].NodeStatus == NodeStatus.Infected)
{
var dayOfInfection = infectionNodes[nodeKey].DayOfInfection;
var resultadoAzar = rand.NextDouble();
var recoveryLikelyhood = new ChiSquareDistribution(_parameters.ChiSquaredRecoveryDistributionDegreesOfFreedom).DistributionFunction(dayOfInfection + 1);
if (resultadoAzar <= recoveryLikelyhood)
{
RecoverNode(nodeKey);
}
else
{
WorsenNode(nodeKey);
}
}
}
foreach (var edge in InfectionVisualNetworks[_currentNetworkKey].Edges)
{
var sourceKey = edge.SourceNode.Id;
var destinationKey = edge.TargetNode.Id;
if ((previousStates[sourceKey].NodeStatus == NodeStatus.Infected && previousStates[destinationKey].NodeStatus == NodeStatus.Susceptible))
{
var resultadoAzar = rand.NextDouble();
//var infectionLikelyhood = _parameters.InfectionProbabilities[previousStates[destinationKey].DayOfInfection];
var infectionLikelyhood = new ChiSquareDistribution(_parameters.ChiSquaredDistributionDegreesOfFreedom).ProbabilityDensityFunction(previousStates[sourceKey].DayOfInfection + 1);
infectionLikelyhood = infectionLikelyhood * _parameters.InfectionChiSquaredFactor;
if (previousStates[destinationKey].NodeType == NodeType.Vaccinated)
{
infectionLikelyhood = infectionLikelyhood * _parameters.VaccineEfficiencyRatio;
}
if (resultadoAzar <= infectionLikelyhood)
{
InfectNode(destinationKey);
}
}
else if ((previousStates[destinationKey].NodeStatus == NodeStatus.Infected && previousStates[sourceKey].NodeStatus == NodeStatus.Susceptible))
{
var resultadoAzar = rand.NextDouble();
//var infectionLikelyhood = _parameters.InfectionProbabilities[previousStates[destinationKey].DayOfInfection];
var infectionLikelyhood = new ChiSquareDistribution(_parameters.ChiSquaredDistributionDegreesOfFreedom).ProbabilityDensityFunction(previousStates[destinationKey].DayOfInfection + 1);
infectionLikelyhood = infectionLikelyhood * _parameters.InfectionChiSquaredFactor;
if (previousStates[sourceKey].NodeType == NodeType.Vaccinated)
{
infectionLikelyhood = infectionLikelyhood * _parameters.VaccineEfficiencyRatio;
}
if (resultadoAzar <= infectionLikelyhood)
{
InfectNode(sourceKey);
}
}
}
networkHistories[_currentNetworkKey].InfectedPerIteration.Add(GetCurrentInfectedNodes());
networkHistories[_currentNetworkKey].AmountIterations++;
return(InfectionVisualNetworks[_currentNetworkKey]);
}
