//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); }
private void GenerateIndividual_Click(object sender, RoutedEventArgs e) { var xCount = int.Parse(XCountRandom.Text); var alternativesCount = int.Parse(AltCountRandom.Text); var constraintsCount = int.Parse(ConstraintCountRandom.Text); var optDirection = OptDirectionComboBoxRandom.SelectedIndex == 0 ? "max" : "min"; var distributionTypeIndex = DistributionType.SelectedIndex; CustomDistribution distribution; switch (distributionTypeIndex) { case 0: distribution = new BetaDistribution(double.Parse(BetaA.Text), double.Parse(BetaB.Text)); break; case 1: distribution = new ChiDistribution(int.Parse(ChiK.Text)); break; case 2: distribution = new GammaDistribution(double.Parse(GammaShape.Text), double.Parse(GammaRate.Text)); break; case 3: distribution = new NormalDistribution(double.Parse(NormalMean.Text), double.Parse(NormalStdDev.Text)); break; case 4: distribution = new UniformDistribution(double.Parse(UniformMin.Text), double.Parse(UniformMax.Text)); break; default: distribution = new NormalDistribution(double.Parse(NormalMean.Text), double.Parse(NormalStdDev.Text)); break; } _viewModel.GenerateIndividualProblem(xCount, alternativesCount, constraintsCount, optDirection, distribution); ResultsSaveStackPanel.Visibility = Visibility.Visible; }
private static void FitToNormalInternal(IEnumerable <double> sample, out double m, out double dm, out double s, out double ds) { // We factor out this method because it is used by both the normal and the log-normal fit methods. // Maximum likelihood estimate is straightforward. // p_i = \frac{1}{\sqrt{2\pi}\sigma} \exp \left[ -\frac{1}{2} \left( \frac{x_i - \mu}{\sigma} \right)^2 \right] // \ln p_i = -\ln (\sqrt{2\pi} \sigma) - \frac{1}{2} \left( \frac{x_i - \mu}{\sigma} \right)^2 // \ln L = \sum_i // so // \frac{\partial \ln L}{\partial \mu} = \sum_i \frac{x_i - \mu}{\sigma^2} // \frac{\partial \ln L}{\partial \sigma} = -\frac{n}{\sigma} - \frac{1}{\sigma^2} \sum_i (x_i - \mu)^2 // Setting equal to zero and solving gives the unsurprising result // \mu = n^{-1} \sum_i x_i // \sigma^2 = n^{-1} \sum_i (x_i - \mu)^2 // that MLE says to estimate the model mean and variance by the sample mean and variance. // MLE estimators are guaranteed to be asymptotically unbiased, but they can be biased for finite n. // You can see that must be the case for \sigma because the denominator has n instead of n-1. // To un-bias our estimators, we will derive exact distributions for these quantities. // First the mean estimator. Start from x_i \sim N(\mu, \sigma). By the addition of normal deviates, // \sum_i x_i \sim N(n \mu, \sqrt{n} \sigma). So // m = \frac{1}{n} \sum_i x_i \sim N(\mu, \sigma / \sqrt{n}). // which means the estimator m is normally distributed with mean \mu and standard deviation // \sigma / \sqrt{n}. Now we know that m is unbiased and we know its variance. int n; double ss; Univariate.ComputeMomentsUpToSecond(sample, out n, out m, out ss); dm = Math.Sqrt(ss) / n; // Next the variance estimator. By the definition of the chi squared distribution and a bit of algebra that // reduces the degrees of freedom by one, u^2 = \sum_i ( \frac{x_i - m}{\sigma} )^2 \sim \chi^2(n - 1), which has // mean n - 1 and variance 2(n-1). Therefore the estimator // v = \sigma^2 u^2 / (n-1) = \frac{1}{n-1} \sum_i ( x_i - m )^2 // has mean \sigma^2 and variance 2 \sigma^4 / (n-1). // If we consider \sigma^2 the parameter, we are done -- we have derived an estimator that is unbiased and // know its variance. But we don't consider the parameter \sigma^2, we consider it \sigma. // The mean of the square root is not the square root of the mean, so the square root of an unbiased // estimator of \sigma^2 will not be an unbiased estimator of \sigma. If we want an unbiased estimator of \sigma // itself, we need to go a bit further. Since u^2 ~ \chi^2(n-1), u ~ \chi(n-1). It's mean is a complicated ratio // of Gamma functions and it's variance is an even more complicated difference whose evaluation can be delicate, // but our machinery in the ChiDistribution class handles that. To get an unbiased estimator of \sigma, we just // need to apply the same principal of dividing by the mean of this distribution. // s = \sigma u / <u> = \sqrt{\sum_i (x_i - m)^2} / <u> // to get an estimator with mean \sigma and known variance. ChiDistribution d = new ChiDistribution(n - 1); s = Math.Sqrt(ss) / d.Mean; ds = d.StandardDeviation / d.Mean * s; }
public void ChiAndChiSquared() { ChiDistribution chi = new ChiDistribution(3); ChiSquaredDistribution chi2 = new ChiSquaredDistribution(3.0); Assert.IsTrue(chi.DegreesOfFreedom == chi2.DegreesOfFreedom); foreach (double x in TestUtilities.GenerateRealValues(1.0E-1, 1.0E1, 4)) { Assert.IsTrue(TestUtilities.IsNearlyEqual(chi.LeftProbability(x), chi2.LeftProbability(x * x))); } }
public void TestChiDistribution() { double[][] para = { new double[] { 7, 0, 2.062729304476599455816607, 0.488171949494276922953910, 3.750618675544098650248806, 0.130564628233938801736407 } }; for (int i = 0; i < para.Length; i++) { var tester = new ContDistTester(para[i], delegate(double a, double b) { var ret = new ChiDistribution { N = (int)a }; return(ret); } ); tester.Test(1E-14); } }
/// <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"); } }