private static void inverse_gaussian_cdf_test() //****************************************************************************80 // // Purpose: // // INVERSE_GAUSSIAN_CDF_TEST tests INVERSE_GAUSSIAN_CDF. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 April 2016 // // Author: // // John Burkardt // { int i; int seed = 123456789; Console.WriteLine(""); Console.WriteLine("INVERSE_GAUSSIAN_CDF_TEST"); Console.WriteLine(" INVERSE_GAUSSIAN_CDF evaluates the Inverse Gaussian CDF;"); Console.WriteLine(" INVERSE_GAUSSIAN_PDF evaluates the Inverse Gaussian PDF;"); const double a = 5.0; const double b = 2.0; Console.WriteLine(""); Console.WriteLine(" PDF parameter A = " + a + ""); Console.WriteLine(" PDF parameter B = " + b + ""); if (!InverseGaussian.inverse_gaussian_check(a, b)) { Console.WriteLine(""); Console.WriteLine("INVERSE_GAUSSIAN_CDF_TEST - Fatal error!"); Console.WriteLine(" The parameters are not legal."); return; } Console.WriteLine(""); Console.WriteLine(" X PDF CDF"); Console.WriteLine(""); for (i = 1; i <= 10; i++) { double x = InverseGaussian.inverse_gaussian_sample(a, b, ref seed); double pdf = InverseGaussian.inverse_gaussian_pdf(x, a, b); double cdf = InverseGaussian.inverse_gaussian_cdf(x, a, b); Console.WriteLine(" " + x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + pdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " " + cdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + ""); } }
public bool Run(SimulationContext context) { IsValid = false; if (context == null) { _logger.Error($"Undefined {nameof(context)}"); return(false); } Context = context; Values = new double[Context.Years, Context.Investments, Context.Simulations]; InverseInvestmentGaussians = new InverseGaussian[Context.Investments]; var random = new Random(); for (var inv = 0; inv < Context.Investments; inv++) { InverseInvestmentGaussians[inv] = new InverseGaussian( Context.MeanMarketReturn * random.NextDouble(), Context.StdDevMarketReturn * random.NextDouble() ); } CalculateSimulations(); SummarizeRawGeometricReturns(); SummarizePortfolioReturnsByYear(); CalculatePortfolioReturnStandardDeviationsByYear(); CalculateGeometricMeanReturnsBySimulation(); IsValid = true; return(true); }
public void ValidateInverseCumulativeDistribution(double mu, double lambda, double probability, double f) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(f, InverseGaussian.ICDF(mu, lambda, probability), precision); AssertHelpers.AlmostEqualRelative(f, n.InvCDF(probability), precision); }
public void CanCreateInverseGaussian(double mu, double lambda) { var n = new InverseGaussian(mu, lambda); Assert.AreEqual(mu, n.Mu); Assert.AreEqual(lambda, n.Lambda); }
public void CanCreateInverseGaussianWithRandomSource() { var randomSource = new Numerics.Random.MersenneTwister(100); var n = new InverseGaussian(1.0, 1.0, randomSource); Assert.AreEqual(randomSource, n.RandomSource); }
public void CanSampleSequence() { var n = new InverseGaussian(1.0, 2.0); var ied = n.Samples(); GC.KeepAlive(ied.Take(5).ToArray()); }
public void ValidateCumulativeDistribution(double mu, double lambda, double x, double f) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(f, n.CumulativeDistribution(x), precision); AssertHelpers.AlmostEqualRelative(f, InverseGaussian.CDF(mu, lambda, x), precision); }
public void ValidateToString() { System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture; var n = new InverseGaussian(1d, 2d); Assert.AreEqual("InverseGaussian(μ = 1, λ = 2)", n.ToString()); }
public void ValidateDensityLn(double mu, double lambda, double x, double p) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(p, n.DensityLn(x), precision); AssertHelpers.AlmostEqualRelative(p, InverseGaussian.PDFLn(mu, lambda, x), precision); }
public void CanFillSampleArray() { double[] samples = new double[100]; var n = new InverseGaussian(1.0, 2.0, new Numerics.Random.MersenneTwister(100)); n.Samples(samples); Assert.IsTrue(!samples.Any(x => x == 0)); }
public void CanEstimateParameters(double mu, double lambda) { var original = new InverseGaussian(mu, lambda, new Numerics.Random.MersenneTwister(100)); var estimated = InverseGaussian.Estimate(original.Samples().Take(1000000)); AssertHelpers.AlmostEqualRelative(mu, estimated.Mu, 1); AssertHelpers.AlmostEqualRelative(lambda, estimated.Lambda, 1); }
public void CanSample() { var n = new InverseGaussian(1.0, 2.0); n.Sample(); }
public void FailSampleSequenceStatic() { Assert.That(() => { var ied = InverseGaussian.Samples(new Numerics.Random.MersenneTwister(100), 0.0, -1.0).First(); }, Throws.ArgumentException); }
public void FailFillingSampleArrayStatic() { double[] samples = new double[100]; Assert.That(() => { InverseGaussian.Samples(new Numerics.Random.MersenneTwister(100), samples, -1.0, 1.0); }, Throws.ArgumentException); }
public void CanSampleSequenceStatic() { var ied = InverseGaussian.Samples(new Numerics.Random.MersenneTwister(100), 1.0, 1.0); GC.KeepAlive(ied.Take(5).ToArray()); }
public void ValidateMean(double mu, double lambda, double mean) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(mean, n.Mean, precision); }
public void ValidateStandardDeviation(double mu, double lambda, double std) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(std, n.StdDev, precision); }
public void ValidateSkewness(double mu, double lambda, double skewness) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(skewness, n.Skewness, precision); }
public void ValidateEntropyFailsWithNotSupported(double mu, double lambda) { var n = new InverseGaussian(mu, lambda); Assert.Throws <NotSupportedException>(() => { var x = n.Entropy; }); }
public void ValidateMaximum() { var n = new InverseGaussian(1.0, 2.0); Assert.AreEqual(Double.PositiveInfinity, n.Maximum); }
public void ValidateMinimum() { var n = new InverseGaussian(1.0, 2.0); Assert.AreEqual(0.0, n.Minimum); }
private static void inverse_gaussian_sample_test() //****************************************************************************80 // // Purpose: // // INVERSE_GAUSSIAN_SAMPLE_TEST tests INVERSE_GAUSSIAN_SAMPLE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 April 2016 // // Author: // // John Burkardt // { const int SAMPLE_NUM = 1000; int i; int seed = 123456789; double[] x = new double [SAMPLE_NUM]; Console.WriteLine(""); Console.WriteLine("INVERSE_GAUSSIAN_SAMPLE_TEST"); Console.WriteLine(" INVERSE_GAUSSIAN_MEAN computes the Inverse Gaussian mean;"); Console.WriteLine(" INVERSE_GAUSSIAN_SAMPLE samples the Inverse Gaussian distribution;"); Console.WriteLine(" INVERSE_GAUSSIAN_VARIANCE computes the Inverse Gaussian variance;"); const double a = 2.0; const double b = 3.0; Console.WriteLine(""); Console.WriteLine(" PDF parameter A = " + a + ""); Console.WriteLine(" PDF parameter B = " + b + ""); if (!InverseGaussian.inverse_gaussian_check(a, b)) { Console.WriteLine(""); Console.WriteLine("INVERSE_GAUSSIAN_SAMPLE_TEST - Fatal error!"); Console.WriteLine(" The parameters are not legal."); return; } double mean = InverseGaussian.inverse_gaussian_mean(a, b); double variance = InverseGaussian.inverse_gaussian_variance(a, b); Console.WriteLine(""); Console.WriteLine(" PDF mean = " + mean + ""); Console.WriteLine(" PDF variance = " + variance + ""); for (i = 0; i < SAMPLE_NUM; i++) { x[i] = InverseGaussian.inverse_gaussian_sample(a, b, ref seed); } mean = typeMethods.r8vec_mean(SAMPLE_NUM, x); variance = typeMethods.r8vec_variance(SAMPLE_NUM, x); double xmax = typeMethods.r8vec_max(SAMPLE_NUM, x); double xmin = typeMethods.r8vec_min(SAMPLE_NUM, x); Console.WriteLine(""); Console.WriteLine(" Sample size = " + SAMPLE_NUM + ""); Console.WriteLine(" Sample mean = " + mean + ""); Console.WriteLine(" Sample variance = " + variance + ""); Console.WriteLine(" Sample maximum = " + xmax + ""); Console.WriteLine(" Sample minimum = " + xmin + ""); }
public void ValidateVariance(double mu, double lambda, double variance) { var n = new InverseGaussian(mu, lambda); AssertHelpers.AlmostEqualRelative(variance, n.Variance, precision); }
public void ValidateIsValidParameterSet(double mu, double lambda, bool validity) { Assert.AreEqual(InverseGaussian.IsValidParameterSet(mu, lambda), validity); }
public void CanFillSampleArrayStatic() { double[] samples = new double[100]; InverseGaussian.Samples(new Numerics.Random.MersenneTwister(100), samples, 1.0, 1.0); Assert.IsTrue(!samples.Any(x => x == 0)); }
public void CanSampleStatic() { InverseGaussian.Sample(new Numerics.Random.MersenneTwister(100), 1.0, 1.0); }
public void ValidateToString() { var n = new InverseGaussian(1d, 2d); Assert.AreEqual("InverseGaussian(μ = 1, λ = 2)", n.ToString()); }