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