protected override void EndProcessing()
{
var dist = new GeometricDistribution(ProbabilityOfSuccess);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void GeometricDistributionConstructorTest()
{
double successProbability = 0.9;
GeometricDistribution target = new GeometricDistribution(successProbability);
Assert.AreEqual(0.9, target.ProbabilityOfSuccess);
Assert.AreEqual((1 - 0.9) / 0.9, target.Mean);
Assert.AreEqual((1 - 0.9) / (0.9 * 0.9), target.Variance);
}
public void GeometricDistributionConstructorTest()
{
double successProbability = 0.9;
GeometricDistribution target = new GeometricDistribution(successProbability);
Assert.AreEqual(0.9, target.ProbabilityOfSuccess);
Assert.AreEqual((1 - 0.9) / 0.9, target.Mean);
Assert.AreEqual((1 - 0.9) / (0.9 * 0.9), target.Variance);
}
public void ConstructorTest()
{
// Create a Geometric distribution with 42% success probability
var dist = new GeometricDistribution(probabilityOfSuccess: 0.42);
double mean = dist.Mean; // 1.3809523809523812
double median = dist.Median; // 1
double var = dist.Variance; // 3.2879818594104315
double mode = dist.Mode; // 0
double cdf = dist.DistributionFunction(k: 2); // 0.80488799999999994
double ccdf = dist.ComplementaryDistributionFunction(k: 2); // 0.19511200000000006
double pdf1 = dist.ProbabilityMassFunction(k: 0); // 0.42
double pdf2 = dist.ProbabilityMassFunction(k: 1); // 0.2436
double pdf3 = dist.ProbabilityMassFunction(k: 2); // 0.141288
double lpdf = dist.LogProbabilityMassFunction(k: 2); // -1.956954918588067
int icdf1 = dist.InverseDistributionFunction(p: 0.17); // 0
int icdf2 = dist.InverseDistributionFunction(p: 0.46); // 1
int icdf3 = dist.InverseDistributionFunction(p: 0.87); // 3
double hf = dist.HazardFunction(x: 0); // 0.72413793103448265
double chf = dist.CumulativeHazardFunction(x: 0); // 0.54472717544167193
string str = dist.ToString(CultureInfo.InvariantCulture); // "Geometric(x; p = 0.42)"
Assert.AreEqual(1.3809523809523812, mean);
Assert.AreEqual(1, median);
Assert.AreEqual(0, mode);
Assert.AreEqual(3.2879818594104315, var);
Assert.AreEqual(0.54472717544167193, chf, 1e-10);
Assert.AreEqual(0.80488799999999994, cdf);
Assert.AreEqual(0.42, pdf1);
Assert.AreEqual(0.2436, pdf2);
Assert.AreEqual(0.14128800000000002, pdf3);
Assert.AreEqual(-1.956954918588067, lpdf);
Assert.AreEqual(0.72413793103448265, hf);
Assert.AreEqual(0.19511200000000006, ccdf);
Assert.AreEqual(0, icdf1);
Assert.AreEqual(1, icdf2);
Assert.AreEqual(3, icdf3);
Assert.AreEqual("Geometric(x; p = 0.42)", str);
var range1 = dist.GetRange(0.95);
var range2 = dist.GetRange(0.99);
var range3 = dist.GetRange(0.01);
Assert.AreEqual(0, range1.Min);
Assert.AreEqual(5, range1.Max);
Assert.AreEqual(0, range2.Min);
Assert.AreEqual(8, range2.Max);
Assert.AreEqual(0, range3.Min);
Assert.AreEqual(8, range3.Max);
}
public void ConstructorTest()
{
// Create a Geometric distribution with 42% success probability
var dist = new GeometricDistribution(probabilityOfSuccess: 0.42);
double mean = dist.Mean; // 1.3809523809523812
double median = dist.Median; // 1
double var = dist.Variance; // 3.2879818594104315
double mode = dist.Mode; // 0
double cdf = dist.DistributionFunction(k: 2); // 0.80488799999999994
double ccdf = dist.ComplementaryDistributionFunction(k: 2); // 0.19511200000000006
double pdf1 = dist.ProbabilityMassFunction(k: 0); // 0.42
double pdf2 = dist.ProbabilityMassFunction(k: 1); // 0.2436
double pdf3 = dist.ProbabilityMassFunction(k: 2); // 0.141288
double lpdf = dist.LogProbabilityMassFunction(k: 2); // -1.956954918588067
int icdf1 = dist.InverseDistributionFunction(p: 0.17); // 0
int icdf2 = dist.InverseDistributionFunction(p: 0.46); // 1
int icdf3 = dist.InverseDistributionFunction(p: 0.87); // 3
double hf = dist.HazardFunction(x: 0); // 0.72413793103448265
double chf = dist.CumulativeHazardFunction(x: 0); // 0.54472717544167193
string str = dist.ToString(CultureInfo.InvariantCulture); // "Geometric(x; p = 0.42)"
Assert.AreEqual(1.3809523809523812, mean);
Assert.AreEqual(1, median);
Assert.AreEqual(0, mode);
Assert.AreEqual(3.2879818594104315, var);
Assert.AreEqual(0.54472717544167193, chf, 1e-10);
Assert.AreEqual(0.80488799999999994, cdf);
Assert.AreEqual(0.42, pdf1);
Assert.AreEqual(0.2436, pdf2);
Assert.AreEqual(0.14128800000000002, pdf3);
Assert.AreEqual(-1.956954918588067, lpdf);
Assert.AreEqual(0.72413793103448265, hf);
Assert.AreEqual(0.19511200000000006, ccdf);
Assert.AreEqual(0, icdf1);
Assert.AreEqual(1, icdf2);
Assert.AreEqual(3, icdf3);
Assert.AreEqual("Geometric(x; p = 0.42)", str);
var range1 = dist.GetRange(0.95);
var range2 = dist.GetRange(0.99);
var range3 = dist.GetRange(0.01);
Assert.AreEqual(0, range1.Min);
Assert.AreEqual(5, range1.Max);
Assert.AreEqual(0, range2.Min);
Assert.AreEqual(8, range2.Max);
Assert.AreEqual(0, range3.Min);
Assert.AreEqual(8, range3.Max);
}
public void CloneTest()
{
double successProbability = 1;
GeometricDistribution target = new GeometricDistribution(successProbability);
GeometricDistribution actual = (GeometricDistribution)target.Clone();
Assert.AreNotEqual(target, actual);
Assert.AreNotSame(target, actual);
Assert.AreEqual(target.ProbabilityOfSuccess, actual.ProbabilityOfSuccess);
}
public void FitTest()
{
double successProbability = 0;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] observations = { 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0 };
double[] weights = null;
IFittingOptions options = null;
target.Fit(observations, weights, options);
Assert.AreEqual(1 / (1 - 4 / 12.0), target.ProbabilityOfSuccess);
}
public void ProbabilityMassFunctionTest()
{
double successProbability = 0.42;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] expected = { 0, 0.42, 0.2436, 0.141288, 0.08194704, 0.0475292832, 0.027566984256 };
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityMassFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void DistributionFunctionTest()
{
double successProbability = 0.42;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] values = { -1, 0, 1, 2, 3, 4, 5 };
double[] expected = { 0, 0.42, 0.6636, 0.804888, 0.88683504, 0.9343643232, 0.961931307456 };
for (int i = 0; i < values.Length; i++)
{
double actual = target.DistributionFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void MedianTest()
{
var target = new GeometricDistribution(0.2);
Assert.AreEqual(0, target.Support.Min);
Assert.AreEqual(int.MaxValue, target.Support.Max);
// qgeom((0:9)/10, prob = .2)
Assert.AreEqual(0, target.InverseDistributionFunction(0.0));
Assert.AreEqual(0, target.InverseDistributionFunction(0.1));
Assert.AreEqual(0, target.InverseDistributionFunction(0.2));
Assert.AreEqual(1, target.InverseDistributionFunction(0.3));
Assert.AreEqual(2, target.InverseDistributionFunction(0.4));
Assert.AreEqual(3, target.InverseDistributionFunction(0.5));
Assert.AreEqual(4, target.InverseDistributionFunction(0.6));
Assert.AreEqual(5, target.InverseDistributionFunction(0.7));
Assert.AreEqual(7, target.InverseDistributionFunction(0.8));
Assert.AreEqual(10, target.InverseDistributionFunction(0.9));
Assert.AreEqual(int.MaxValue, target.InverseDistributionFunction(1.0));
}
public void TestGeometricDistribution()
{
double[][] para =
{
// note since Mathematica has variant B, you must increase the third value here by one
new double[] { 0.125, 0, 5, 0.4870910644531250000000000, 0.07327270507812500000000000 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new DiscDistTester(para[i], delegate(double a, double b)
{
var ret = new GeometricDistribution
{
Probability = a
};
return(ret);
}
);
tester.Test(1E-14);
}
}
public void MedianTest()
{
{
var target = new GeometricDistribution(0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.000001);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.99999);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
public void FitTest2()
{
double successProbability = 0;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] observations = { 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0 };
double[] weights = { 0, 1, 1, 2, 0, 2, 1, 0, 0, 0, 1, 0 };
weights = weights.Divide(weights.Sum());
IFittingOptions options = null;
target.Fit(observations, weights, options);
Assert.AreEqual(1 / (1 - 4.0 / 8.0), target.ProbabilityOfSuccess);
}
public void DistributionFunctionTest()
{
double successProbability = 0.42;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] values = { -1, 0, 1, 2, 3, 4, 5 };
double[] expected = { 0, 0.42, 0.6636, 0.804888, 0.88683504, 0.9343643232, 0.961931307456 };
for (int i = 0; i < values.Length; i++)
{
double actual = target.DistributionFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
public void CloneTest()
{
double successProbability = 1;
GeometricDistribution target = new GeometricDistribution(successProbability);
GeometricDistribution actual = (GeometricDistribution)target.Clone();
Assert.AreNotEqual(target, actual);
Assert.AreNotSame(target, actual);
Assert.AreEqual(target.ProbabilityOfSuccess, actual.ProbabilityOfSuccess);
}
public static void Main(string[] args)
{
List <double> transmissoesSucesso = new List <double>();
//Console.WriteLine("Hello World!");
int nEstacoesProntas = 0;
//Inicialização:
Slot slot = new Slot();
slot.estacoes = new List <Estacao>();
slot.tContador = 1; //alterar
slot.nEstacoes = 5; //??
int nSlotsOciosos = 0;
int nSlotsTransmitidos = 0;
int nSlotsComColisao = 0;
for (int i = 0; i < slot.nEstacoes; i++)
{
//??
Estacao estacao = new Estacao(i, ExponentialDistribution.Random(0.05), 0, 0);
slot.estacoes.Add(estacao);
}
//iterando os slots
for (int k = 0; k < 10000; k++)
{
//iterando as estações
for (int i = 0; i < slot.nEstacoes; i++)
{
if (slot.estacoes[i].tProximaChegada <= slot.tContador)
{
if (slot.estacoes[i].nNaFila == 0)
{
slot.estacoes[i].tProximaTransmissao = slot.tContador + 1;
}
slot.estacoes[i].nNaFila += 1;
}
}
nEstacoesProntas = 0;
List <Estacao> estacoesProntas = new List <Estacao>();
for (int i = 0; i < slot.nEstacoes; i++)
{
if (slot.estacoes[i].tProximaTransmissao <= slot.tContador)
{
nEstacoesProntas += 1; //armazenar aqui as estações prontas
estacoesProntas.Add(slot.estacoes[i]);
}
}
//para a questão 2
if (estacoesProntas.Count == 1)
{
transmissoesSucesso.Add(Math.Abs(slot.tContador - estacoesProntas[0].tProximaChegada));
}
switch (nEstacoesProntas)
{
case 0:
nSlotsOciosos += 1;
break;
case 1:
nSlotsTransmitidos += 1;
for (int i = 0; i < estacoesProntas.Count; i++)
{
estacoesProntas[i].nNaFila += 1;
estacoesProntas[i].tProximaTransmissao = slot.tContador + 1;
}
break;
default:
nSlotsComColisao += 1;
for (int i = 0; i < estacoesProntas.Count; i++)
{
estacoesProntas[i].tProximaTransmissao = estacoesProntas[i].tProximaTransmissao + GeometricDistribution.Random(0.05);
}
//extra
for (int i = 0; i < slot.estacoes.Count; i++)
{
if (estacoesProntas.Where(x => x.id == slot.estacoes[i].id).FirstOrDefault() != null)
{
slot.estacoes[i] = estacoesProntas.Where(x => x.id == slot.estacoes[i].id).FirstOrDefault();
}
}
break;
}
slot.tContador += 1;
}
Console.WriteLine("Transmitidos: " + nSlotsTransmitidos + " Ociosos: " + nSlotsOciosos + " Colisões: " + nSlotsComColisao);
int total = (nSlotsTransmitidos + nSlotsOciosos + nSlotsComColisao);
double percentual = double.Parse(nSlotsTransmitidos.ToString()) / double.Parse(total.ToString());
Console.WriteLine("\n Taxa de sucesso: " + percentual + " \n");
Console.WriteLine("\n Média de espera: " + transmissoesSucesso.Average() + " \n");
Console.WriteLine("\n Variância: " + Math.Pow(StandardDeviation(transmissoesSucesso), 2) + " \n");
//Iterações
//for (int i = 0; i < slot.nEstacoes; i++)
//{
// Console.WriteLine(slot.estacoes[i].tProximaChegada);
//}
}
public GeometricDistributionDialogView(GeometricDistribution geometricDistribution)
{
InitializeComponent();
DataContext = new GeometricDistributionDialogViewModel(geometricDistribution, this);
}
/// <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>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( GeometricDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function );
return chart;
}
public void FirstSuccessWithin(int n, double p, double expected)
{
Assert.Equal(expected, GeometricDistribution.FirstSuccessWithin(n, p));
}
public void ProbabilityMassFunctionTest()
{
double successProbability = 0.42;
GeometricDistribution target = new GeometricDistribution(successProbability);
double[] expected = { 0, 0.42, 0.2436, 0.141288, 0.08194704, 0.0475292832, 0.027566984256 };
for (int i = 0; i < expected.Length; i++)
{
double actual = target.ProbabilityMassFunction(i - 1);
Assert.AreEqual(expected[i], actual, 1e-10);
Assert.IsFalse(Double.IsNaN(actual));
}
}
/// <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>
/// <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, GeometricDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
List<string> titles = new List<string>()
{
"GeometricDistribution",
String.Format("p={0}", dist.P)
};
UpdateDiscreteDistribution( ref chart, dist, titles, function );
}
public void MedianTest()
{
{
var target = new GeometricDistribution(0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.000001);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
var target = new GeometricDistribution(0.99999);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
/// <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>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function ) );
/// </code>
/// </remarks>
public static void Show( GeometricDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
Show( ToChart( dist, function ) );
}
/// <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 Probability(int n, double p, double expected)
{
Assert.Equal(expected, GeometricDistribution.Probability(n, p));
}
