public void MaritzJarrettConfidenceIntervalWeighedTest1() { var random = new Random(42); var distribution = new BetaDistribution(2, 10); double[] data = distribution.Random(random).Next(10); var sample1 = new Sample(data); var sample2 = new Sample(data, new ConstantSequence(1).GenerateArray(data.Length)); var sample3 = new Sample( data.Concat(new[] { 10.0, 10.0, 10.0 }).ToArray(), new ConstantSequence(1).GenerateArray(data.Length).Concat(new[] { 0.0, 0.0, 0.0 }).ToArray() ); var estimator = HarrellDavisQuantileEstimator.Instance; var probability = Probability.Half; var level = ConfidenceLevel.L90; var ci1 = estimator.GetQuantileConfidenceIntervalEstimator(sample1, probability).GetConfidenceInterval(level); var ci2 = estimator.GetQuantileConfidenceIntervalEstimator(sample2, probability).GetConfidenceInterval(level); var ci3 = estimator.GetQuantileConfidenceIntervalEstimator(sample3, probability).GetConfidenceInterval(level); Output.WriteLine("CI1: " + ci1.ToString("N9")); Output.WriteLine("CI2: " + ci2.ToString("N9")); Output.WriteLine("CI3: " + ci3.ToString("N9")); var comparer = new AbsoluteEqualityComparer(1e-9); Assert.True(ci1.Equals(ci2, comparer)); Assert.True(ci1.Equals(ci3, comparer)); }
public void BetaMeanTest() { double alpha = 0.42; double beta = 1.57; BetaDistribution betaDistribution = new BetaDistribution(alpha, beta); double mean = betaDistribution.Mean; // 0.21105527638190955 double median = betaDistribution.Median; // 0.11577706212908731 double var = betaDistribution.Variance; // 0.055689279830523512 double chf = betaDistribution.CumulativeHazardFunction(x: 0.27); // 1.1828193992944409 double cdf = betaDistribution.DistributionFunction(x: 0.27); // 0.69358638272337991 double pdf = betaDistribution.ProbabilityDensityFunction(x: 0.27); // 0.94644031936694828 double lpdf = betaDistribution.LogProbabilityDensityFunction(x: 0.27); // -0.055047364344046057 double hf = betaDistribution.HazardFunction(x: 0.27); // 3.0887671630877072 double ccdf = betaDistribution.ComplementaryDistributionFunction(x: 0.27); // 0.30641361727662009 double icdf = betaDistribution.InverseDistributionFunction(p: cdf); // 0.26999999068687469 string str = betaDistribution.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 0.42, β = 1.57) Assert.AreEqual(0.21105527638190955, mean); Assert.AreEqual(0.11577706212908731, median); Assert.AreEqual(0.055689279830523512, var); Assert.AreEqual(1.1828193992944409, chf); Assert.AreEqual(0.69358638272337991, cdf); Assert.AreEqual(0.94644031936694828, pdf); Assert.AreEqual(-0.055047364344046057, lpdf); Assert.AreEqual(3.0887671630877072, hf); Assert.AreEqual(0.30641361727662009, ccdf); Assert.AreEqual(0.27, icdf, 1e-10); Assert.AreEqual("B(x; α = 0.42, β = 1.57)", str); Assert.IsFalse(Double.IsNaN(median)); }
public void HarrellDavisQuantileEstimatorWeightedTest1() { var random = new Random(42); var distribution = new BetaDistribution(2, 10); double[] data1 = distribution.Random(random).Next(10); double[] data2 = data1.Select(x => x + 100).ToArray(); double[] data = data1.Concat(data2).ToArray(); var samples = new List <Sample> { new Sample(data1) }; for (int i = 1; i <= 40; i++) { samples.Add(new Sample(data, ExponentialDecaySequence.CreateFromHalfLife(i).GenerateArray(data.Length))); } samples.Add(new Sample(data)); var medians = samples.Select(s => HarrellDavisQuantileEstimator.Instance.GetMedian(s)).ToList(); for (int i = 0; i < medians.Count; i++) { Output.WriteLine($"Median[{i}] = {medians[i]:N9}"); } for (int i = 0; i < medians.Count - 1; i++) { Assert.True(medians[i] < medians[i + 1]); } }
public async Task YeetItem([Remainder] string item) { var avatar = EntityConverter.ConvertUser(Context.User); var factory = new PlayerFighterFactory(); var p = factory.CreatePlayerFighter(avatar); var inv = avatar.Inv; var embed = new EmbedBuilder(); var it = inv.GetItem(item); if (inv.Remove(item)) { UserAccountProvider.StoreUser(avatar); var maxdist = p.Stats.Atk * Math.Sqrt(p.Stats.Spd) / Math.Log(Math.Max(it.Price / 2, 2)) / 6; var level = Math.Min(avatar.LevelNumber, 100); var a = 5 + (double)level / 2; var b = 55 - (double)level / 2; var beta = new BetaDistribution(a, b); embed.WithDescription( $"{Context.User.Username} yeets {it.Icon}{it.Name} {Math.Round(beta.Generate(1).FirstOrDefault() * maxdist, 2)} meters away."); embed.WithColor(it.Color); _ = Context.Channel.SendMessageAsync("", false, embed.Build()); } else { embed.WithDescription(":x: You can only get rid of unequipped items in your possession."); embed.WithColor(Colors.Get("Error")); _ = Context.Channel.SendMessageAsync("", false, embed.Build()); } await Task.CompletedTask; }
public void BetaMLEFitTest1() { double[] x = samples; { BetaDistribution target = new BetaDistribution(0, 1); var options = new BetaOptions() { Method = BetaEstimationMethod.Moments }; target.Fit(x, options); Assert.AreEqual(1, target.Alpha, 0.04); Assert.AreEqual(3, target.Beta, 0.5); } { BetaDistribution target = new BetaDistribution(0, 1); var options = new BetaOptions() { Method = BetaEstimationMethod.MaximumLikelihood }; target.Fit(x, options); Assert.AreEqual(1, target.Alpha, 0.04); Assert.AreEqual(3, target.Beta, 0.55); } }
public void MaritzJarrettConfidenceIntervalTest(double confidenceLevel, double minSuccessRate, double maxSuccessRate) { var random = new Random(42); var distribution = new BetaDistribution(2, 10); var generator = new LimitedRandomGenerator(distribution.Random(random).Next(1000), random); var estimator = HarrellDavisQuantileEstimator.Instance; double median = distribution.Median; const int iterations = 1000; for (int n = 5; n <= 10; n++) { int successCount = 0; for (int i = 0; i < iterations; i++) { var sample = generator.Next(n).ToSample(); var confidenceInterval = estimator .GetQuantileConfidenceIntervalEstimator(sample, 0.5) .GetConfidenceInterval(confidenceLevel); if (confidenceInterval.Contains(median)) { successCount++; } } double successRate = successCount * 1.0 / iterations; Output.WriteLine($"n = {n}, successRate = {successRate:N4}"); Assert.True(minSuccessRate <= successRate && successRate <= maxSuccessRate); } }
//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; }
public void BetaInversion() { // test that beta distribution is accurately inverted over a wide range of a, b, P foreach (double a in TestUtilities.GenerateRealValues(0.01, 100.0, 8)) { foreach (double b in cs) { BetaDistribution B = new BetaDistribution(a, b); foreach (double P in probabilities) { Console.WriteLine("a={0} b={1} P={2}", a, b, P); double x = B.InverseLeftProbability(P); Console.WriteLine(" x={0} P(x)={1}", x, B.LeftProbability(x)); // we would like to test that P(x) = P, but floating point limitations prevent us from meeting this standard // P(x) changes so fast at extremes that sometimes even the minimal change in x causes a change // in P(x) larger than our target precision; so instead we test that our routine gets us // as close as it can, by checking that P(x-e) < P < P(x+e) double Px = B.LeftProbability(x); double Pxm = B.LeftProbability(Math.Min(0.0, x * (1.0 - TestUtilities.TargetPrecision))); double Pxp = B.LeftProbability(Math.Max(x * (1.0 + TestUtilities.TargetPrecision), 1.0)); Assert.IsTrue((Pxm <= P) && (P <= Pxp)); } } } }
public void BetaDistributionConstructorTest() { double expected, actual; { BetaDistribution target = new BetaDistribution(1.73, 4.2); actual = target.ProbabilityDensityFunction(-1); expected = 0; Assert.AreEqual(expected, actual, 1e-7); Assert.IsFalse(Double.IsNaN(actual)); actual = target.ProbabilityDensityFunction(0); expected = 0; Assert.AreEqual(expected, actual, 1e-7); Assert.IsFalse(Double.IsNaN(actual)); actual = target.ProbabilityDensityFunction(1); expected = 0; Assert.AreEqual(expected, actual, 1e-7); Assert.IsFalse(Double.IsNaN(actual)); actual = target.ProbabilityDensityFunction(0.2); expected = 2.27095841; Assert.AreEqual(expected, actual, 1e-7); Assert.IsFalse(Double.IsNaN(actual)); actual = target.ProbabilityDensityFunction(0.4); expected = 1.50022749; Assert.AreEqual(expected, actual, 1e-7); Assert.IsFalse(Double.IsNaN(actual)); } }
public void TestBivariateRegression() { // Do a bunch of linear regressions. r^2 should be distributed as expected. double a0 = 1.0; double b0 = 0.0; Random rng = new Random(1001110000); ContinuousDistribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-2.0, 4.0)); ContinuousDistribution eDistribution = new NormalDistribution(); List <double> r2Sample = new List <double>(); for (int i = 0; i < 500; i++) { BivariateSample xySample = new BivariateSample(); for (int k = 0; k < 10; k++) { double x = xDistribution.GetRandomValue(rng); double y = a0 + b0 * x + eDistribution.GetRandomValue(rng); xySample.Add(x, y); } LinearRegressionResult fit = xySample.LinearRegression(); double a = fit.Intercept.Value; double b = fit.Slope.Value; r2Sample.Add(fit.RSquared); } ContinuousDistribution r2Distribution = new BetaDistribution((2 - 1) / 2.0, (10 - 2) / 2.0); TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution); Assert.IsTrue(ks.Probability > 0.05); }
public void MedianTest() { double alpha = 0.42; double beta = 1.57; BetaDistribution target = new BetaDistribution(alpha, beta); Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5)); }
public void TestBetaRoundTrip() { // arrange var expected = new BetaDistribution(0.5, 0.5, 0.3, 0.7); // act var serialized = expected.ToString(); var deserialized = Distribution.DeserializeDistribution(serialized); var distribution = deserialized.IfNone(() => { Assert.Fail(); return(default !); });
public void BetaMeanTest() { double alpha = 0.42; double beta = 1.57; BetaDistribution betaDistribution = new BetaDistribution(alpha, beta); double mean = betaDistribution.Mean; // 0.21105527638190955 double median = betaDistribution.Median; // 0.11577706212908731 double var = betaDistribution.Variance; // 0.055689279830523512 double mode = betaDistribution.Mode; // 57.999999999999957 double chf = betaDistribution.CumulativeHazardFunction(x: 0.27); // 1.1828193992944409 double cdf = betaDistribution.DistributionFunction(x: 0.27); // 0.69358638272337991 double pdf = betaDistribution.ProbabilityDensityFunction(x: 0.27); // 0.94644031936694828 double lpdf = betaDistribution.LogProbabilityDensityFunction(x: 0.27); // -0.055047364344046057 double hf = betaDistribution.HazardFunction(x: 0.27); // 3.0887671630877072 double ccdf = betaDistribution.ComplementaryDistributionFunction(x: 0.27); // 0.30641361727662009 double icdf = betaDistribution.InverseDistributionFunction(p: cdf); // 0.26999999068687469 string str = betaDistribution.ToString(System.Globalization.CultureInfo.InvariantCulture); // "B(x; α = 0.42, β = 1.57) Assert.AreEqual(0.21105527638190955, mean); Assert.AreEqual(0.11577706212908731, median); Assert.AreEqual(57.999999999999957, mode); Assert.AreEqual(0.055689279830523512, var); Assert.AreEqual(1.1828193992944409, chf); Assert.AreEqual(0.69358638272337991, cdf); Assert.AreEqual(0.94644031936694828, pdf); Assert.AreEqual(-0.055047364344046057, lpdf); Assert.AreEqual(3.0887671630877072, hf); Assert.AreEqual(0.30641361727662009, ccdf); Assert.AreEqual(0.27, icdf, 1e-10); Assert.AreEqual("B(x; α = 0.42, β = 1.57)", str); Assert.IsFalse(Double.IsNaN(median)); var range1 = betaDistribution.GetRange(0.95); var range2 = betaDistribution.GetRange(0.99); var range3 = betaDistribution.GetRange(0.01); Assert.AreEqual(0.00045925525776717733, range1.Min); Assert.AreEqual(0.72381020663218609, range1.Max); Assert.AreEqual(0.0000099485893745082635, range2.Min); Assert.AreEqual(0.89625688707910811, range2.Max); Assert.AreEqual(0.0000099485893745082432, range3.Min); Assert.AreEqual(0.89625688707910811, range3.Max); Assert.AreEqual(0, betaDistribution.Support.Min); Assert.AreEqual(1, betaDistribution.Support.Max); Assert.AreEqual(betaDistribution.InverseDistributionFunction(0), betaDistribution.Support.Min); Assert.AreEqual(betaDistribution.InverseDistributionFunction(1), betaDistribution.Support.Max); }
public void BetaFitTest1() { double[] x = { 0.1, 0.5, 0.3, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9, 0.9 }; BetaDistribution target = new BetaDistribution(0, 1); target.Fit(x); Assert.AreEqual(1.1810718232044195, target.Alpha); Assert.AreEqual(0.60843093922651903, target.Beta); }
public void TestBetaWithBoundsGetSample() { // arrange var subject = new BetaDistribution(0.5, 0.5, 0.3, 0.7); // act var sample = subject.GetSample(); // assert Assert.IsTrue(sample > 0.3 && sample < 0.7); }
// Start is called before the first frame update void Start() { rnd = new System.Random(); betaDistribution = new BetaDistribution(); bandits = new Bandit[numberOfBandits]; for (int i = 0; i < numberOfBandits; i++) { bandits[i] = new Bandit(rnd.NextDouble()); } }
public void BetaFit_IntWeights() { double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 }; int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 }; BetaDistribution target = new BetaDistribution(0, 1); target.Fit(x, w); Assert.AreEqual(1.1810718232044195, target.Alpha); Assert.AreEqual(0.60843093922651903, target.Beta, 1e-8); }
public void TestBetaWithBoundsFillSamples() { // arrange var subject = new BetaDistribution(0.5, 0.5, 0.3, 0.7); var samples = Range(0, 42).Map(_ => NaN).ToArray(); // act subject.FillSamples(samples); // assert Assert.IsTrue(samples.All(d => d > 0.3 && d < 0.7)); }
public void BetaFit_RealWeights() { double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 }; int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 }; BetaDistribution target = new BetaDistribution(0, 1); target.Fit(x, w.ToDouble()); Assert.AreEqual(1.1401591160220996, target.Alpha); Assert.AreEqual(0.58735469613259694, target.Beta); }
public void TestMultivariateRegression() { double cz = 1.0; double cx = 0.0; double cy = 0.0; Random rng = new Random(1001110000); Distribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-4.0, 8.0)); Distribution yDistribution = new UniformDistribution(Interval.FromEndpoints(-8.0, 4.0)); Distribution eDistribution = new NormalDistribution(); Sample r2Sample = new Sample(); for (int i = 0; i < 500; i++) { MultivariateSample xyzSample = new MultivariateSample(3); for (int k = 0; k < 12; k++) { double x = xDistribution.GetRandomValue(rng); double y = yDistribution.GetRandomValue(rng); double z = cx * x + cy * y + cz + eDistribution.GetRandomValue(rng); xyzSample.Add(x, y, z); } FitResult fit = xyzSample.LinearRegression(2); double fcx = fit.Parameters[0]; double fcy = fit.Parameters[1]; double fcz = fit.Parameters[2]; double ss2 = 0.0; double ss1 = 0.0; foreach (double[] xyz in xyzSample) { ss2 += MoreMath.Sqr(xyz[2] - (fcx * xyz[0] + fcy * xyz[1] + fcz)); ss1 += MoreMath.Sqr(xyz[2] - xyzSample.Column(2).Mean); } double r2 = 1.0 - ss2 / ss1; r2Sample.Add(r2); } Console.WriteLine("{0} {1} {2} {3} {4}", r2Sample.Count, r2Sample.PopulationMean, r2Sample.StandardDeviation, r2Sample.Minimum, r2Sample.Maximum); Distribution r2Distribution = new BetaDistribution((3 - 1) / 2.0, (12 - 3) / 2.0); //Distribution r2Distribution = new BetaDistribution((10 - 2) / 2.0, (2 - 1) / 2.0); Console.WriteLine("{0} {1}", r2Distribution.Mean, r2Distribution.StandardDeviation); TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution); Console.WriteLine(ks.RightProbability); Console.WriteLine(ks.Probability); }
public async Task TestBetaCumulativeDistributionAtBounds() { // arrange var subject = new BetaDistribution(0.5, 0.5, 0.3, 0.7); var expectedLowerP = (await GetNumDataAsync("pbeta(0.3, 0.5, 0.5)"))[0].Data[0]; var expectedUpperP = (await GetNumDataAsync("pbeta(0.7, 0.5, 0.5)"))[0].Data[0]; // act var(actualLowerP, actualUpperP) = subject.CumulativeDistributionAtBounds; // assert Assert.AreEqual(expectedLowerP, actualLowerP, Base.Constant.TOLERANCE); Assert.AreEqual(expectedUpperP, actualUpperP, Base.Constant.TOLERANCE); }
public static (double faintSuspicion, double strongSuspicion) GetSuspicionLevels(double mean, double sigma, double faintSuspicionCoefficient, double strongSuspicionCoefficient) { if (Math.Abs(sigma) < 1e-7) { return(1, 1); } var(alpha, beta) = GetBetaParameters(mean, sigma); var betaDistribution = new BetaDistribution(alpha, beta); var faintSigmaToProbability = new NormalDistribution(0, 1).DistributionFunction(faintSuspicionCoefficient); var strongSigmaToProbability = new NormalDistribution(0, 1).DistributionFunction(strongSuspicionCoefficient); var faintSuspicion = betaDistribution.InverseDistributionFunction(faintSigmaToProbability); var strongSuspicion = betaDistribution.InverseDistributionFunction(strongSigmaToProbability); return(faintSuspicion, strongSuspicion); }
public async Task TestBetaGetDensities() { // arrange var subject = new BetaDistribution(0.5, 0.5); var expected = (await GetNumDataAsync( "sapply(seq(qbeta(0.3, 0.5, 0.5), qbeta(0.7, 0.5, 0.5), length.out = 5), function(cd){dbeta(cd, 0.5, 0.5)})" ))[0].Data.ToArr(); // act var(_, actual) = subject.GetDensities(0.3, 0.7, 5); // assert Assert.IsTrue(actual.Count == 5); expected.Iter((i, d) => Assert.AreEqual(d, actual[i], Base.Constant.TOLERANCE)); }
protected override void EndProcessing() { BetaDistribution dist; if (ParameterSetName == "Alpha") { dist = new BetaDistribution(Alpha, Beta); } else { dist = new BetaDistribution(Successes, Trials); } var obj = DistributionHelper.AddConvinienceMethods(dist); WriteObject(obj); }
public void BetaGenerateTest() { Accord.Math.Tools.SetupGenerator(0); int n = 100000; double[] samples = BetaDistribution .Random(alpha: 2, beta: 3, samples: n); Assert.AreEqual(n, samples.Length); var actual = BetaDistribution.Estimate(samples); Assert.AreEqual(2, actual.Alpha, 1e-2); Assert.AreEqual(3, actual.Beta, 1e-2); }
public void LogLikelihoodTest() { var target = new BetaDistribution(3.0, 2.0); double sum = 0; for (int i = 0; i < samples.Length; i++) { sum -= target.LogProbabilityDensityFunction(samples[i]); } double expected = sum; double actual = BetaDistribution.LogLikelihood(samples, target.Alpha, target.Beta); Assert.AreEqual(expected, actual, 1e-10); }
public void TestBivariateRegression() { double a0 = 1.0; double b0 = 0.0; Random rng = new Random(1001110000); Distribution xDistribution = new UniformDistribution(Interval.FromEndpoints(-2.0, 4.0)); Distribution eDistribution = new NormalDistribution(); Sample r2Sample = new Sample(); for (int i = 0; i < 500; i++) { BivariateSample xySample = new BivariateSample(); for (int k = 0; k < 10; k++) { double x = xDistribution.GetRandomValue(rng); double y = a0 + b0 * x + eDistribution.GetRandomValue(rng); xySample.Add(x, y); } FitResult fit = xySample.LinearRegression(); double a = fit.Parameters[0]; double b = fit.Parameters[1]; double ss2 = 0.0; double ss1 = 0.0; foreach (XY xy in xySample) { ss2 += MoreMath.Sqr(xy.Y - (a + b * xy.X)); ss1 += MoreMath.Sqr(xy.Y - xySample.Y.Mean); } double r2 = 1.0 - ss2 / ss1; r2Sample.Add(r2); } Console.WriteLine("{0} {1} {2} {3} {4}", r2Sample.Count, r2Sample.PopulationMean, r2Sample.StandardDeviation, r2Sample.Minimum, r2Sample.Maximum); Distribution r2Distribution = new BetaDistribution((2 - 1) / 2.0, (10 - 2) / 2.0); //Distribution r2Distribution = new BetaDistribution((10 - 2) / 2.0, (2 - 1) / 2.0); Console.WriteLine("{0} {1}", r2Distribution.Mean, r2Distribution.StandardDeviation); TestResult ks = r2Sample.KolmogorovSmirnovTest(r2Distribution); Console.WriteLine(ks.RightProbability); Console.WriteLine(ks.Probability); }
public void TestBetaDistribution() { double[][] para = { new double[] { 2.5, 3.5, 0.2739037303169420423172000, 1.749247541974141744140178, 0.7393662913208028693203748, 0.5988730468534031966438193 } }; for (int i = 0; i < para.Length; i++) { var tester = new ContDistTester(para[i], delegate(double a, double b) { var ret = new BetaDistribution(a, b); return(ret); } ); tester.Test(1E-14); } }
public void BetaMLEFit_IntWeights() { double[] x = { 1.0, 0.1, 0.5, 0.3, 0.5, 0.8, 0.6, 0.7, 0.9, 0.9, 0.9 }; int[] w = { 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 2 }; BetaDistribution target = new BetaDistribution(0, 1); var options = new BetaOptions() { Method = BetaEstimationMethod.MaximumLikelihood }; target.Fit(x, w, options); Assert.AreEqual(1.1810718232044195, target.Alpha); Assert.AreEqual(0.60843093922651903, target.Beta, 1e-10); }
/* public Distribution( DistributionType name, double value1, double value2 ) { this.name = name; this.value1 = value1; this.value2 = value2; }*/ //--------------------------------------------------------------------- public static double GenerateRandomNum(DistributionType dist, double parameter1, double parameter2) { double randomNum = 0.0; /*if(dist == DistributionType.Normal) { NormalDistribution randVar = new NormalDistribution(RandomNumberGenerator.Singleton); randVar.Mu = parameter1; // mean randVar.Sigma = parameter2; // std dev randomNum = randVar.NextDouble(); } if(dist == DistributionType.Lognormal) { LognormalDistribution randVar = new LognormalDistribution(RandomNumberGenerator.Singleton); randVar.Mu = parameter1; // mean randVar.Sigma = parameter2; // std dev randomNum = randVar.NextDouble(); }*/ if(dist == DistributionType.Weibull) { WeibullDistribution randVar = new WeibullDistribution(RandomNumberGenerator.Singleton); randVar.Alpha = parameter1; // mean randVar.Lambda = parameter2; // std dev randomNum = randVar.NextDouble(); } if(dist == DistributionType.Gamma) { GammaDistribution randVar = new GammaDistribution(RandomNumberGenerator.Singleton); randVar.Alpha = parameter1; // mean randVar.Theta = parameter2; // std dev randomNum = randVar.NextDouble(); } if(dist == DistributionType.Beta) { BetaDistribution randVar = new BetaDistribution(RandomNumberGenerator.Singleton); randVar.Alpha = parameter1; // mean randVar.Beta = parameter2; // std dev randomNum = randVar.NextDouble(); } return randomNum; }
/// <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( BetaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 ) { ChartControl chart = GetDefaultChart(); Update( ref chart, dist, function, numInterpolatedValues ); return chart; }
/// <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, BetaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 ) { List<string> titles = new List<string>() { "BetaDistribution", String.Format("\u03B1={0}, \u03B2={1}", dist.Alpha, dist.Beta) }; UpdateContinuousDistribution( ref chart, dist, titles, function, numInterpolatedValues ); }
/// <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( BetaDistribution dist, DistributionFunction function = DistributionFunction.PDF, int numInterpolatedValues = 100 ) { Show( ToChart( dist, function, numInterpolatedValues ) ); }