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 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 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)); }
/// <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 ); }
/// <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)); }