public static IEnumerable<float> TestData()
{
var g = new Normal(0.0, 1.0);
var randy = new MersenneTwister();
g.RandomSource = randy;
var dbls = new double[100000];
g.Samples(dbls);
return dbls.Select(d => (float) d);
}
public void NormalityTestAlgorithmTest()
{
int sampleSize = 100;
int numberOfMonteCarloTests = 5;
double result = 0;
NormalityTest.NormalityTestFunc normalityTestFunc = NormalityTest.JaqueBeraTest;
// normal distribution
Console.WriteLine("normal var");
for (int i = 0; i < numberOfMonteCarloTests; i++)
{
var distribution = new Normal(50, 1);
distribution.RandomSource = new Random(DateTime.Now.Millisecond * i);
var normalSamples = distribution.Samples().Take(sampleSize);
double[] reallIsNormalSamples = normalSamples.ToArray();
result = normalityTestFunc(reallIsNormalSamples);
Console.WriteLine("reallIsNormalSamples_" + i + ": " + result);
}
Console.WriteLine();
// random distribution.
Console.WriteLine("rand var");
Random rnd = new Random();
double[] randomArray = new double[sampleSize];
for (int i = 0; i < numberOfMonteCarloTests; i++)
{
for (int j = 0; j < sampleSize; j++)
{
randomArray[j] = rnd.Next(1, 100);
}
result = normalityTestFunc(randomArray);
Console.WriteLine("randomArray_" + i + ": " + result);
}
Console.WriteLine();
// Uniform distribution
Console.WriteLine("rand var");
var uniformSamples = new Normal(100, 0).Samples().Take(sampleSize);
double[] uniformSamplesRandomVar = uniformSamples.ToArray();
result = normalityTestFunc(uniformSamplesRandomVar);
Console.WriteLine("uniformSamples: " + result);
}
private void GenerateUCube(DISTRIBUTION d)
{
if (array != null)
{
return;
}
array = new double[number_of_sims][][];
var uniform = new MathNet.Numerics.Random.MersenneTwister(seed);
var normal = new MathNet.Numerics.Distributions.Normal(0, 1, uniform);
Func <double[]> rgn = null;
switch (d)
{
case DISTRIBUTION.UNIFORM:
rgn = () =>
{
return(uniform.NextDoubles((int)number_of_steps));
};
break;
case DISTRIBUTION.NORMAL:
rgn = () =>
{
double[] r = new double[number_of_steps];
normal.Samples(r);
return(r);
};
break;
}
for (UInt64 i = 0; i < number_of_sims; ++i)
{
array[i] = new double[number_of_dims][];
for (UInt64 j = 0; j < number_of_dims; ++j)
{
array[i][j] = rgn();
}
}
}
public void CanEstimateParameters(double mean, double stddev)
{
var original = new Normal(mean, stddev, new Random(100));
var estimated = Normal.Estimate(original.Samples().Take(10000));
AssertHelpers.AlmostEqualRelative(mean, estimated.Mean, 1);
AssertHelpers.AlmostEqualRelative(stddev, estimated.StdDev, 1);
}
public void CanSampleSequence()
{
var n = new Normal();
var ied = n.Samples();
GC.KeepAlive(ied.Take(5).ToArray());
}
public void StabilityMeanVariance()
{
// Test around 10^9, potential stability issues
var gaussian = new Normal(1e+9, 2, new MersenneTwister(100));
AssertHelpers.AlmostEqualRelative(1e+9, Statistics.Mean(gaussian.Samples().Take(10000)), 10);
AssertHelpers.AlmostEqualRelative(4d, Statistics.Variance(gaussian.Samples().Take(10000)), 0);
AssertHelpers.AlmostEqualRelative(2d, Statistics.StandardDeviation(gaussian.Samples().Take(10000)), 1);
AssertHelpers.AlmostEqualRelative(1e+9, Statistics.RootMeanSquare(gaussian.Samples().Take(10000)), 10);
AssertHelpers.AlmostEqualRelative(1e+9, ArrayStatistics.Mean(gaussian.Samples().Take(10000).ToArray()), 10);
AssertHelpers.AlmostEqualRelative(4d, ArrayStatistics.Variance(gaussian.Samples().Take(10000).ToArray()), 0);
AssertHelpers.AlmostEqualRelative(2d, ArrayStatistics.StandardDeviation(gaussian.Samples().Take(10000).ToArray()), 1);
AssertHelpers.AlmostEqualRelative(1e+9, ArrayStatistics.RootMeanSquare(gaussian.Samples().Take(10000).ToArray()), 10);
AssertHelpers.AlmostEqualRelative(1e+9, StreamingStatistics.Mean(gaussian.Samples().Take(10000)), 10);
AssertHelpers.AlmostEqualRelative(4d, StreamingStatistics.Variance(gaussian.Samples().Take(10000)), 0);
AssertHelpers.AlmostEqualRelative(2d, StreamingStatistics.StandardDeviation(gaussian.Samples().Take(10000)), 1);
AssertHelpers.AlmostEqualRelative(1e+9, StreamingStatistics.RootMeanSquare(gaussian.Samples().Take(10000)), 10);
AssertHelpers.AlmostEqualRelative(1e+9, new RunningStatistics(gaussian.Samples().Take(10000)).Mean, 10);
AssertHelpers.AlmostEqualRelative(4d, new RunningStatistics(gaussian.Samples().Take(10000)).Variance, 0);
AssertHelpers.AlmostEqualRelative(2d, new RunningStatistics(gaussian.Samples().Take(10000)).StandardDeviation, 1);
}
/// <summary>
/// Generates a sequence of samples from the log-normal distribution using the <i>Box-Muller</i> algorithm.
/// </summary>
/// <param name="rnd">The random number generator to use.</param>
/// <param name="mu">The log-scale (μ) of the distribution.</param>
/// <param name="sigma">The shape (σ) of the distribution. Range: σ ≥ 0.</param>
/// <returns>a sequence of samples from the distribution.</returns>
public static IEnumerable <double> Samples(System.Random rnd, double mu, double sigma)
{
return(Normal.Samples(rnd, mu, sigma).Select(Math.Exp));
}
/// <summary>
/// Generates a sequence of samples from the log-normal distribution using the <i>Box-Muller</i> algorithm.
/// </summary>
/// <returns>a sequence of samples from the distribution.</returns>
public IEnumerable <double> Samples()
{
return(Normal.Samples(_random, _mu, _sigma).Select(Math.Exp));
}
private static double[] GenerateNoisePath(int simulationSteps, int mean, double noiseVariance)
{
var standardNormal = new Normal(mean, noiseVariance);
return standardNormal.Samples().Take(simulationSteps).ToArray();
}
public void CanSampleSequence()
{
var n = new Normal();
var ied = n.Samples();
var e = ied.Take(5).ToArray();
}
public static double[] Randn(int n, double mu = 0.0, double sigma = 1.0)
{
Normal d = new Normal(mu, sigma);
double[] ret = d.Samples().Take(n).ToArray();
return ret;
}