//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);
}
public void LogProbabilityDensityFunctionTest()
{
double a = -5;
double b = 11;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
double x = 4.2;
double expected = System.Math.Log(0.0625);
double actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual);
x = -5;
expected = System.Math.Log(0.0625);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual);
x = -6;
expected = System.Math.Log(0.0);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual);
x = 11;
expected = System.Math.Log(0.0625);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual);
x = 12;
expected = System.Math.Log(0.0);
actual = target.LogProbabilityDensityFunction(x);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Build linear samples.
/// </summary>
/// <param name="x">X sample values.</param>
/// <param name="y">Y samples values.</param>
/// <param name="xtest">X test values.</param>
/// <param name="ytest">Y test values.</param>
/// <param name="samples">Sample values.</param>
/// <param name="sampleOffset">Sample offset.</param>
/// <param name="slope">Slope number.</param>
/// <param name="intercept">Intercept criteria.</param>
public static void Build(out double[] x, out double[] y, out double[] xtest, out double[] ytest, int samples = 3, double sampleOffset = -0.5, double slope = 2.0, double intercept = -1.0)
{
// Fixed-seed "random" distribution to ensure we always test with the same data
var uniform = new ContinuousUniformDistribution(0.0, 1.0, new Random(42));
// build linear samples
x = new double[samples];
y = new double[samples];
for (int i = 0; i < x.Length; i++)
{
x[i] = i + sampleOffset;
y[i] = (x[i] * slope) + intercept;
}
// build linear test vectors randomly between the sample points
xtest = new double[samples + 1];
ytest = new double[samples + 1];
if (samples == 1)
{
// y = const
xtest[0] = sampleOffset - uniform.Sample();
xtest[1] = sampleOffset + uniform.Sample();
ytest[0] = ytest[1] = (sampleOffset * slope) + intercept;
}
else
{
for (int i = 0; i < xtest.Length; i++)
{
xtest[i] = (i - 1) + sampleOffset + uniform.Sample();
ytest[i] = (xtest[i] * slope) + intercept;
}
}
}
public void ContinuousUniformDistribution()
{
Simulation.NumberOfSamples = 5;
JsonSerializer serializer = JsonSerializer.Create(JsonSettings.SerializerSettings);
string name = "My Distribution";
var val = new ContinuousUniformDistribution(1.0, 5.0, 0)
{
Name = name
};
Guid guid = val.Guid;
string json = JObject.FromObject(val, serializer).ToString();
Simulation.ClearDistributionList();
var newVal = JObject.Parse(json).ToObject <ContinuousUniformDistribution>(serializer);
Assert.AreEqual(val.Guid, newVal.Guid);
Assert.AreEqual(val.ConstrainedToInt, newVal.ConstrainedToInt);
Assert.AreEqual(val.RandomSeed, newVal.RandomSeed);
Assert.AreEqual(val.Min.ScalarValue, newVal.Min.ScalarValue);
Assert.AreEqual(val.Minimum, newVal.Minimum);
Assert.AreEqual(val.Max.ScalarValue, 5);
Assert.AreEqual(val.Maximum, newVal.Maximum);
Assert.AreEqual(val.Mean, newVal.Mean);
Assert.AreEqual(val.Name, name);
}
public static double ContinuousUniform(double min, double max, bool cache)
{
if (min == max)
{
return(min);
}
Debug.Assert(min < max);
ContinuousUniformDistribution uniform;
Pair <double, double> key = new Pair <double, double>(min, max);
if (!continuousUniformGenerators.ContainsKey(key))
{
uniform = new ContinuousUniformDistribution(generator);
AlphaAndBeta(uniform, min, max);
// Beta must always be greater than alpha, so we set them this way round
if (cache)
{
continuousUniformGenerators.Add(key, uniform);
}
}
else
{
uniform = continuousUniformGenerators[key];
}
Debug.Assert(uniform != null);
Debug.Assert(uniform.Alpha == min);
Debug.Assert(uniform.Beta == max);
double value = uniform.NextDouble();
Debug.Assert(value >= min && value <= max);
return(value);
}
public void TestStatistics()
{
Simulation.NumberOfSamples = 100000;
var distr = new ContinuousUniformDistribution(1, 12345);
Assert.AreEqual(Statistics.Mean(distr.GetResult()), distr.Mean);
Assert.AreEqual(Statistics.Median(distr.GetResult()), distr.Median);
Assert.AreEqual(Statistics.StandardDeviation(distr.GetResult()), distr.StandardDeviation);
Assert.AreEqual(Statistics.Variance(distr.GetResult()), distr.Variance);
Assert.AreEqual(Statistics.Minimum(distr.GetResult()), distr.Minimum);
Assert.AreEqual(Statistics.Maximum(distr.GetResult()), distr.Maximum);
Assert.AreEqual(Statistics.Percentile(distr.GetResult(), 0), distr.Percentile(0));
Assert.AreEqual(Statistics.Percentile(distr.GetResult(), 5), distr.Percentile(5));
Assert.AreEqual(Statistics.Percentile(distr.GetResult(), 50), distr.Percentile(50));
Assert.AreEqual(Statistics.Percentile(distr.GetResult(), 95), distr.Percentile(95));
Assert.AreEqual(Statistics.Percentile(distr.GetResult(), 100), distr.Percentile(100));
var histogram = new Histogram(distr.GetResult(), 100);
for (int i = 0; i < histogram.BucketCount; i++)
{
Assert.AreEqual(histogram[i].LowerBound, distr.Histogram[i].LowerBound);
Assert.AreEqual(histogram[i].UpperBound, distr.Histogram[i].UpperBound);
}
}
static void BuildLinearCase(int start, int stop, out double[] x, out double[] y, out double[] xtest, out double[] ytest)
{
const double yOffset = 2.0;
int samples = stop - start + 1;
ContinuousUniformDistribution uniform = new ContinuousUniformDistribution();
// build linear samples
x = new double[samples];
y = new double[samples];
for (int i = 0; i < x.Length; i++)
{
int z = start + i;
x[i] = z;
y[i] = z + yOffset; // arbitrary small y-axis offset
}
// build linear test vectors randomly between the sample points
xtest = new double[samples + 1];
ytest = new double[samples + 1];
if (samples == 1)
{
xtest[0] = start - uniform.NextDouble();
xtest[1] = start + uniform.NextDouble();
ytest[0] = ytest[1] = start + yOffset;
}
else
{
for (int i = 0; i < xtest.Length; i++)
{
double z = (i - 1) + uniform.NextDouble();
xtest[i] = z;
ytest[i] = z + yOffset;
}
}
}
public void CreateIntaceOfAttractRepulseGenerator_PassEachParameterAsNullAndOtherIsCorrect_ArgumentNullExceptionThrown(
Solution bestSolution, IEnumerable <Dimension> dimensions, ContinuousUniformDistribution distribution, System.Random randomizer, string expectedParamName)
{
ArgumentNullException exeption = Assert.Throws <ArgumentNullException>(
() => new AttractRepulseSparkGenerator(bestSolution, dimensions, distribution, randomizer));
Assert.Equal(expectedParamName, exeption.ParamName);
}
public void UniformDistributionConstructorTest()
{
double a = 1;
double b = 5;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
Assert.AreEqual(target.Minimum, a);
Assert.AreEqual(target.Maximum, b);
}
public RandomizerOptions(double min, double max, double sigma = 0.25)
{
Min = min;
Max = max;
Mean = (Min + Max) / 2.0;
Sigma = sigma;
Normal = new NormalDistribution(Mean, Sigma);
Uniform = new ContinuousUniformDistribution(Min, Max);
}
public void TestOptimalVariance()
{
ContinuousUniformDistribution dist = new ContinuousUniformDistribution(0, 10);
Histogram h = Histogram.OptimalVariance(10, new List <double>(dist.EnumerateDoubles(1000)));
Assert.That(h.Count, Is.EqualTo(10));
Console.WriteLine(h.ToString());
}
public void MeanTest()
{
double a = -1;
double b = 5;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
double expected = (a + b) / 2.0;
double actual = target.Mean;
Assert.AreEqual(expected, actual);
}
public void VarianceTest()
{
double a = 5;
double b = 10;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
double actual = target.Variance;
double expected = System.Math.Pow(b - a, 2) / 12.0;
Assert.AreEqual(expected, actual);
}
public void ResetSampleGeneration()
{
phi = new double[frequencyIntervals];
var Phi = new ContinuousUniformDistribution(0d, 2d * Math.PI);
for (int i = 0; i < frequencyIntervals; i++)
{
phi[i] = Phi.NextDouble();
}
}
public void EntropyTest()
{
double a = 1;
double b = 6;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
double expected = System.Math.Log(b - a);
double actual = target.Entropy;
Assert.AreEqual(expected, actual);
}
public void FitTest()
{
ContinuousUniformDistribution target = new ContinuousUniformDistribution();
double[] observations = { -1, 2, 5, 2, 3, 1, 4 };
double[] weights = null;
target.Fit(observations, weights);
Assert.AreEqual(-1.0, target.Minimum);
Assert.AreEqual(5.0, target.Maximum);
}
// A routine to work around the mis-feature in setting alpha and beta
private static void AlphaAndBeta(ContinuousUniformDistribution distribution, double alpha, double beta)
{
distribution.Alpha = Math.Min(alpha, distribution.Alpha);
distribution.Beta = Math.Max(beta, distribution.Beta);
distribution.Alpha = alpha;
distribution.Beta = beta;
Debug.Assert(distribution.Alpha == alpha);
Debug.Assert(distribution.Beta == beta);
}
public static ISparkGenerator CreateAttractRepulseSparkGenerator()
{
Solution bestSolution = Substitute.For <Solution>(0);
IList <Dimension> dimensions = Substitute.For <IList <Dimension> >();
ContinuousUniformDistribution distribution = Substitute.For <ContinuousUniformDistribution>(Amplitude - Delta, Amplitude + Delta);
System.Random randomizer = Substitute.For <System.Random>();
AttractRepulseSparkGenerator generator = Substitute.For <AttractRepulseSparkGenerator>(bestSolution, dimensions, distribution, randomizer);
return(generator);
}
private void precomputeSeeds(int seed, int amount)
{
var g = new MT19937Generator(seed);
ContinuousUniformDistribution rand = new ContinuousUniformDistribution(g);
seedList = new int[amount];
for (int i = 0; i < seedList.Length; i++)
{
seedList[i] = (int)(rand.NextDouble() * MAX);
}
}
public void UniformDistributionConstructorTest1()
{
double a = 6;
double b = 5;
bool thrown = false;
try { ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b); }
catch (ArgumentOutOfRangeException) { thrown = true; }
Assert.IsTrue(thrown);
}
public void ImplicitOperatorDistributionDouble()
{
Simulation.NumberOfSamples = ExpectedResults.NumberOfSamples;
ContinuousUniformDistribution distr = new ContinuousUniformDistribution(1.0, 1000.0);
QrtValue qrtVal = distr;
Assert.IsTrue(qrtVal.IsDistribution);
Assert.IsFalse(qrtVal.ConstrainedToInt);
Assert.AreEqual(qrtVal.ScalarValue, 0);
Assert.AreEqual(qrtVal.DistributionValue.GetResult(), distr.GetResult());
}
public void IndexDistribution()
{
Simulation.NumberOfSamples = ExpectedResults.NumberOfSamples;
ContinuousUniformDistribution distr = new ContinuousUniformDistribution(1.0, 1000.0);
QrtValue qrtVal = distr;
for (int i = 0; i < ExpectedResults.NumberOfSamples; i++)
{
Assert.AreEqual(distr.GetResult()[i], qrtVal[i]);
}
}
static Rng()
{
// Create a commonly-used and quicly locatable zeroOrOne distribution,
// and also reference it in the discreteUniformGeneratirs dictionary
zeroOrOne = new DiscreteUniformDistribution(generator);
AlphaAndBeta(zeroOrOne, 0, 1);
discreteUniformGenerators.Add(new Pair <int, int>(0, 1), zeroOrOne);
// Create a commonly-used and quickly locatable zeroToOne distribution,
// and also reference it in the continuousUniformGenerators dictionary
zeroToOne = new ContinuousUniformDistribution(generator);
AlphaAndBeta(zeroToOne, 0.0, 1.0);
continuousUniformGenerators.Add(new Pair <double, double>(0.0, 1.0), zeroToOne);
}
public int HabitiationParameter(HabitationParameterType habitationParameterType)
{
switch (habitationParameterType)
{
case HabitationParameterType.Gravity:
case HabitationParameterType.Temperature:
return((int)Math.Round(TrapezoidalDistribution.Sample(this.rng, -49.5, 49.5, -40, 40)));
case HabitationParameterType.Radiation:
return((int)Math.Round(ContinuousUniformDistribution.Sample(this.rng, -49.5, 49.5)));
default:
throw new ArgumentOutOfRangeException(nameof(habitationParameterType), habitationParameterType, null);
}
}
public void CloneTest()
{
double a = 12;
double b = 72;
ContinuousUniformDistribution target = new ContinuousUniformDistribution(a, b);
ContinuousUniformDistribution clone = (ContinuousUniformDistribution)target.Clone();
Assert.AreNotSame(target, clone);
Assert.AreEqual(target.Entropy, clone.Entropy);
Assert.AreEqual(target.Maximum, clone.Maximum);
Assert.AreEqual(target.Minimum, clone.Minimum);
Assert.AreEqual(target.StandardDeviation, clone.StandardDeviation);
Assert.AreEqual(target.Variance, clone.Variance);
}
public void TestOptimalSquaredFreedom()
{
ContinuousUniformDistribution dist = new ContinuousUniformDistribution(0, 10);
Histogram h = Histogram.OptimalSquaredFreedom(10, new List <double>(dist.EnumerateDoubles(1000)));
h.JoinBuckets();
Assert.That(h.GetContainerOf(8).LowerBound, Is.LessThanOrEqualTo(8.0));
Assert.That(h.GetContainerOf(8).UpperBound, Is.GreaterThanOrEqualTo(8.0));
Assert.That(h.GetContainerIndexOf(11), Is.LessThan(0.0));
Assert.That(h.GetContainerIndexOf(-1), Is.LessThan(0.0));
Assert.That(delegate { h.GetContainerOf(11); }, Throws.TypeOf(typeof(ArgumentException)));
Assert.That(delegate { h.GetContainerOf(-1); }, Throws.TypeOf(typeof(ArgumentException)));
Assert.That(h.Count, Is.EqualTo(10));
Console.WriteLine(h.ToString());
}
public Form1()
{
InitializeComponent();
//--
mTranslations = new Dictionary <string, Translations>();
mPlainListWords = new PlainWords();
//--
mBinominalDistr = new BinomialDistribution();
mTriangleDistr = new TriangularDistribution();
mUniformDistr = new DiscreteUniformDistribution();
mContUniformDist = new ContinuousUniformDistribution();
mRnd = new Random();
mStopTimer = false;
}
public void TestContinuousUniformDistribution()
{
double[][] para =
{
new double[] { 3, 5, 3.500000000000000000000000, 0.5000000000000000000000000, 4.900000000000000000000000, 0.5000000000000000000000000 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new ContDistTester(para[i], delegate(double a, double b)
{
var ret = new ContinuousUniformDistribution(a, b);
return(ret);
}
);
tester.Test(1E-14);
}
}
public void KolmogorovSmirnovTestConstructorTest()
{
// Test against a Uniform distribution
// References: http://www.math.nsysu.edu.tw/~lomn/homepage/class/92/kstest/kolmogorov.pdf
double[] sample = { 0.621, 0.503, 0.203, 0.477, 0.710, 0.581, 0.329, 0.480, 0.554, 0.382 };
ContinuousUniformDistribution distribution = ContinuousUniformDistribution.Standard;
var target = new KolmogorovSmirnovTest(sample, distribution);
Assert.AreEqual(distribution, target.TheoreticalDistribution);
Assert.AreEqual(Hypothesis.TwoTail, target.Hypothesis);
Assert.AreEqual(0.29, target.Statistic, 1e-16);
Assert.AreEqual(0.3067, target.PValue, 1e-4);
Assert.IsFalse(Double.IsNaN(target.Statistic));
}
public void Distribution_Resample()
{
Simulation.NumberOfSamples = 100000;
var testInfo = ExpectedResults.Data["DistributionResults"]["ContinuousUniformDistribution"];
var inputs = testInfo["ConstructorInputs"];
ContinuousUniformDistribution distr = new ContinuousUniformDistribution(
inputs["min"].Value <double>(),
inputs["max"].Value <double>(),
inputs["randomSeed"].Value <int>());
var resampledDist = distr.Resample();
Assert.AreEqual(distr.Maximum, resampledDist.Maximum);
Assert.AreEqual(distr.Minimum, resampledDist.Minimum);
Assert.AreEqual(distr.Mean, resampledDist.Mean, 10);
Assert.AreEqual(distr.Median, resampledDist.Median);
Assert.AreEqual(distr.StandardDeviation, resampledDist.StandardDeviation, 10);
Assert.AreEqual(distr.Variance, resampledDist.Variance, 10);
Assert.AreEqual(distr.ConstrainedToInt, resampledDist.ConstrainedToInt);
Assert.IsTrue(
distr.GetResult()[0] != resampledDist.GetResult()[0] ||
distr.GetResult()[1] != resampledDist.GetResult()[1] ||
distr.GetResult()[2] != resampledDist.GetResult()[2] ||
distr.GetResult()[3] != resampledDist.GetResult()[3] ||
distr.GetResult()[4] != resampledDist.GetResult()[4]);
Assert.AreEqual(distr.Percentile(0), resampledDist.Percentile(0));
Assert.AreEqual(distr.Percentile(25), resampledDist.Percentile(25));
Assert.AreEqual(distr.Percentile(50), resampledDist.Percentile(50));
Assert.AreEqual(distr.Percentile(75), resampledDist.Percentile(75));
Assert.AreEqual(distr.Percentile(100), resampledDist.Percentile(100));
// Force recalculation by changing seed on original distribution
distr.RandomSeed = distr.RandomSeed + 1;
Assert.AreEqual(distr.Maximum, resampledDist.Maximum);
Assert.AreEqual(distr.Minimum, resampledDist.Minimum);
Assert.AreEqual(distr.Mean, resampledDist.Mean, 10);
Assert.AreEqual(distr.Median, resampledDist.Median);
Assert.AreEqual(distr.StandardDeviation, resampledDist.StandardDeviation, 10);
Assert.AreEqual(distr.Variance, resampledDist.Variance, 10);
}
void InitDistributions()
{
_uniformDistribution = new ContinuousUniformDistribution(RandomSource);
_uniformDistribution.SetDistributionParameters(-Constants.Pi_2, Constants.Pi_2);
_exponentialDistribution = new ExponentialDistribution(RandomSource);
_exponentialDistribution.SetDistributionParameters(1.0);
}
