public async Task TestLaplaceDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.LaplaceB01M0(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.0000000000000000).Within(0.05));
Assert.That(result[1], Is.EqualTo(0.9048374180359590).Within(0.05));
Assert.That(result[2], Is.EqualTo(0.8187307530779810).Within(0.05));
Assert.That(result[21], Is.EqualTo(0.1224564282529820).Within(0.05));
Assert.That(result[22], Is.EqualTo(0.1108031583623340).Within(0.05));
Assert.That(result[23], Is.EqualTo(0.1002588437228040).Within(0.05));
Assert.That(result[50], Is.EqualTo(0.0067379469990855).Within(0.003));
Assert.That(result[75], Is.EqualTo(0.0005530843701478).Within(0.0015));
Assert.That(result[85], Is.EqualTo(0.0002034683690106).Within(0.0015));
Assert.That(result[90], Is.EqualTo(0.0001234098040867).Within(0.0015));
Assert.That(result[97], Is.EqualTo(0.0000612834950532).Within(0.0002));
Assert.That(result[98], Is.EqualTo(0.0000554515994322).Within(0.0002));
Assert.That(result[99], Is.EqualTo(0.0000501746820562).Within(0.0002));
}
public async Task TestExponentialDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.InverseExponentialLa5(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.007083408929052f).Within(0.008f));
Assert.That(result[1], Is.EqualTo(0.007446583070924f).Within(0.008f));
Assert.That(result[2], Is.EqualTo(0.007828377549226f).Within(0.008f));
Assert.That(result[21], Is.EqualTo(0.020241911445804f).Within(0.05f));
Assert.That(result[22], Is.EqualTo(0.021279736438377f).Within(0.05f));
Assert.That(result[23], Is.EqualTo(0.022370771856166f).Within(0.05f));
Assert.That(result[50], Is.EqualTo(0.08629358649937f).Within(0.02f));
Assert.That(result[75], Is.EqualTo(0.301194211912202f).Within(0.03f));
Assert.That(result[85], Is.EqualTo(0.496585303791409f).Within(0.05f));
Assert.That(result[90], Is.EqualTo(0.637628151621772f).Within(0.06f));
Assert.That(result[97], Is.EqualTo(0.904837418035959f).Within(0.08f));
Assert.That(result[98], Is.EqualTo(0.951229424500713f).Within(0.08f));
Assert.That(result[99], Is.EqualTo(1f).Within(0.08f));
}
public async Task TestChiSquareDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.ChiSquareK4(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.016417705906679).Within(0.02));
Assert.That(result[1], Is.EqualTo(0.032671644513723).Within(0.02));
Assert.That(result[2], Is.EqualTo(0.048763041010352).Within(0.02));
Assert.That(result[21], Is.EqualTo(0.32518779111264).Within(0.05));
Assert.That(result[22], Is.EqualTo(0.338273451612642).Within(0.05));
Assert.That(result[23], Is.EqualTo(0.351220492939994).Within(0.05));
Assert.That(result[50], Is.EqualTo(0.65209223303425).Within(0.08));
Assert.That(result[75], Is.EqualTo(0.857562207152294).Within(0.099));
Assert.That(result[85], Is.EqualTo(0.923072405412387).Within(0.099));
Assert.That(result[90], Is.EqualTo(0.952623623874265).Within(0.099));
Assert.That(result[97], Is.EqualTo(0.990616879396201).Within(0.099));
Assert.That(result[98], Is.EqualTo(0.995734077068522).Within(0.099));
Assert.That(result[99], Is.EqualTo(1.00077558852585).Within(0.1));
}
public async Task TestLogNormalDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.LogNormalS1M0(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.001505531f).Within(0.003f));
Assert.That(result[1], Is.EqualTo(0.014408709f).Within(0.01f));
Assert.That(result[2], Is.EqualTo(0.043222256f).Within(0.02f));
Assert.That(result[21], Is.EqualTo(0.876212056f).Within(0.15f));
Assert.That(result[22], Is.EqualTo(0.895582226f).Within(0.15f));
Assert.That(result[23], Is.EqualTo(0.912837250f).Within(0.15f));
Assert.That(result[50], Is.EqualTo(0.948062005f).Within(0.2f));
Assert.That(result[75], Is.EqualTo(0.768584762f).Within(0.089f));
Assert.That(result[85], Is.EqualTo(0.697303612f).Within(0.089f));
Assert.That(result[90], Is.EqualTo(0.663570581f).Within(0.089f));
Assert.That(result[97], Is.EqualTo(0.618792767f).Within(0.089f));
Assert.That(result[98], Is.EqualTo(0.612636410f).Within(0.089f));
Assert.That(result[99], Is.EqualTo(0.606540679f).Within(0.089f));
}
public async Task TestExponentialDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.ExponentialLa5(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.0002177398625f).Within(0.05f));
Assert.That(result[1], Is.EqualTo(0.951436545064811f).Within(0.05f));
Assert.That(result[2], Is.EqualTo(0.905034437210948f).Within(0.05f));
Assert.That(result[21], Is.EqualTo(0.35001394450853f).Within(0.05f));
Assert.That(result[22], Is.EqualTo(0.332943563002074f).Within(0.05f));
Assert.That(result[23], Is.EqualTo(0.31670571382568f).Within(0.05f));
Assert.That(result[50], Is.EqualTo(0.082102871800213f).Within(0.01f));
Assert.That(result[75], Is.EqualTo(0.023522866606758f).Within(0.01f));
Assert.That(result[85], Is.EqualTo(0.014267339801329f).Within(0.01f));
Assert.That(result[90], Is.EqualTo(0.011111415409621f).Within(0.01f));
Assert.That(result[97], Is.EqualTo(0.007830082099077f).Within(0.008f));
Assert.That(result[98], Is.EqualTo(0.007448204488898f).Within(0.008f));
Assert.That(result[99], Is.EqualTo(0.007084951269538f).Within(0.008f));
}
public async Task TestExponentialDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.ExponentialLa10(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.00075018434777f).Within(0.05f));
Assert.That(result[1], Is.EqualTo(0.905516212904248f).Within(0.05f));
Assert.That(result[2], Is.EqualTo(0.81934495207398f).Within(0.05f));
Assert.That(result[21], Is.EqualTo(0.122548293148741f).Within(0.12f));
Assert.That(result[22], Is.EqualTo(0.110886281157421f).Within(0.12f));
Assert.That(result[23], Is.EqualTo(0.10033405633809f).Within(0.12f));
Assert.That(result[50], Is.EqualTo(0.00674300170146f).Within(0.005f));
Assert.That(result[75], Is.EqualTo(0.000553499285385f).Within(0.001f));
Assert.That(result[85], Is.EqualTo(0.000203621007796f).Within(0.001f));
Assert.That(result[90], Is.EqualTo(0.00012350238419f).Within(0.001f));
Assert.That(result[97], Is.EqualTo(0.0000613294689720f).Within(0.0008f));
Assert.That(result[98], Is.EqualTo(0.0000554931983541f).Within(0.0008f));
Assert.That(result[99], Is.EqualTo(0.0000502123223173f).Within(0.0008f));
}
public async Task TestUniformDistribution01()
{
const double A = 0.0;
const double B = 1.0;
const double MEAN = 0.5 * (A + B);
const double VARIANCE = (1.0 / 12.0) * (B - A) * (B - A);
var stats = new RunningStatistics();
var fra = new FrequencyAnalysis();
using var rng = new MultiThreadedRng();
for (var n = 0; n < 100_000; n++)
{
var value = await rng.GetUniform();
stats.Push(value);
fra.CountThis(value);
}
fra.NormalizeAndPlotEvents(TestContext.WriteLine);
fra.PlotOccurence(TestContext.WriteLine);
TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
TestContext.WriteLine($"variance={VARIANCE} vs {stats.Variance}");
Assert.That(stats.Mean, Is.EqualTo(MEAN).Within(0.01), "Mean is out of range");
Assert.That(stats.Variance, Is.EqualTo(VARIANCE).Within(0.001), "Variance is out of range");
}
public async Task TestNormalDistribution01()
{
const float MEAN = 0.5f;
const float STANDARD_DEVIATION = 0.2f;
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.NormalS02M05(rng);
var stats = new RunningStatistics();
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
var nextNumber = await dist.NextNumber();
stats.Push(nextNumber);
fra.CountThis(nextNumber);
}
fra.NormalizeAndPlotEvents(TestContext.WriteLine);
TestContext.WriteLine($"mean={MEAN} vs. {stats.Mean}");
TestContext.WriteLine($"variance={STANDARD_DEVIATION * STANDARD_DEVIATION} vs {stats.Variance}");
Assert.That(stats.Mean, Is.EqualTo(MEAN).Within(0.01f), "Mean is out of range");
Assert.That(stats.Variance, Is.EqualTo(STANDARD_DEVIATION * STANDARD_DEVIATION).Within(0.01f), "Variance is out of range");
}
public async Task TestBetaDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.BetaA2B5(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.11719271).Within(0.3));
Assert.That(result[1], Is.EqualTo(0.22505783).Within(0.3));
Assert.That(result[2], Is.EqualTo(0.32401717).Within(0.3));
Assert.That(result[21], Is.EqualTo(0.99348410).Within(0.3));
Assert.That(result[22], Is.EqualTo(0.98639433).Within(0.3));
Assert.That(result[23], Is.EqualTo(0.97684451).Within(0.3));
Assert.That(result[50], Is.EqualTo(0.35868592).Within(0.3));
Assert.That(result[75], Is.EqualTo(0.03076227).Within(0.03));
Assert.That(result[85], Is.EqualTo(0.00403061).Within(0.03));
Assert.That(result[90], Is.EqualTo(0.00109800).Within(0.01));
Assert.That(result[97], Is.EqualTo(0.00000191).Within(0.000003));
Assert.That(result[98], Is.EqualTo(0.00000012).Within(0.0000003));
Assert.That(result[99], Is.EqualTo(0.00000000).Within(0.0000003));
}
public async Task TestGammaDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.GammaA5B15(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0000929594237282f).Within(0.0008f));
Assert.That(result[1], Is.EqualTo(0.0012801746797876f).Within(0.002f));
Assert.That(result[2], Is.EqualTo(0.0055781488254349f).Within(0.004f));
Assert.That(result[21], Is.EqualTo(0.9331608887752720f).Within(0.09f));
Assert.That(result[22], Is.EqualTo(0.9594734828891280f).Within(0.09f));
Assert.That(result[23], Is.EqualTo(0.9790895765535350f).Within(0.09f));
Assert.That(result[50], Is.EqualTo(0.3478287795336570f).Within(0.06f));
Assert.That(result[75], Is.EqualTo(0.0403399049422936f).Within(0.009f));
Assert.That(result[85], Is.EqualTo(0.0163628388658126f).Within(0.009f));
Assert.That(result[90], Is.EqualTo(0.0097147611446660f).Within(0.005f));
Assert.That(result[97], Is.EqualTo(0.0041135143233153f).Within(0.008f));
Assert.That(result[98], Is.EqualTo(0.0036872732029996f).Within(0.008f));
Assert.That(result[99], Is.EqualTo(0.0033038503429554f).Within(0.008f));
}
public async Task TestCauchyDistribution01()
{
// The properties of the cauchy distribution cannot be tested by mean, media or variance,
// cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.CauchyLorentzX0(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.976990739772031f).Within(0.06f));
Assert.That(result[1], Is.EqualTo(0.948808314586299f).Within(0.06f));
Assert.That(result[2], Is.EqualTo(0.905284997403441f).Within(0.06f));
Assert.That(result[21], Is.EqualTo(0.168965864241396f).Within(0.04f));
Assert.That(result[22], Is.EqualTo(0.156877686354491f).Within(0.04f));
Assert.That(result[23], Is.EqualTo(0.145970509936354f).Within(0.04f));
Assert.That(result[50], Is.EqualTo(0.036533159835978f).Within(0.01f));
Assert.That(result[75], Is.EqualTo(0.016793067514802f).Within(0.01f));
Assert.That(result[85], Is.EqualTo(0.01316382933791f).Within(0.005f));
Assert.That(result[90], Is.EqualTo(0.011773781734516f).Within(0.005f));
Assert.That(result[97], Is.EqualTo(0.010168596941156f).Within(0.005f));
Assert.That(result[98], Is.EqualTo(0.009966272570142f).Within(0.005f));
Assert.That(result[99], Is.EqualTo(0.00976990739772f).Within(0.005f));
}
public async Task TestBetaDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.BetaA5B2(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0000001f).Within(0.0000003f));
Assert.That(result[1], Is.EqualTo(0.0000019f).Within(0.00001f));
Assert.That(result[2], Is.EqualTo(0.0000096f).Within(0.0004f));
Assert.That(result[21], Is.EqualTo(0.0222918f).Within(0.03f));
Assert.That(result[22], Is.EqualTo(0.0262883f).Within(0.03f));
Assert.That(result[23], Is.EqualTo(0.0307623f).Within(0.03f));
Assert.That(result[50], Is.EqualTo(0.4044237f).Within(0.2f));
Assert.That(result[75], Is.EqualTo(0.9768445f).Within(0.15f));
Assert.That(result[85], Is.EqualTo(0.9552714f).Within(0.15f));
Assert.That(result[90], Is.EqualTo(0.8004420f).Within(0.35f));
Assert.That(result[97], Is.EqualTo(0.2250578f).Within(0.03f));
Assert.That(result[98], Is.EqualTo(0.1171927f).Within(0.03f));
Assert.That(result[99], Is.EqualTo(0f).Within(0.0004f));
}
public async Task TestInverseGammaDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.InverseGammaA3B05(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0000000000000003).Within(0.0000001));
Assert.That(result[1], Is.EqualTo(0.0000011605257228).Within(0.00001));
Assert.That(result[2], Is.EqualTo(0.0009536970016103).Within(0.0015));
Assert.That(result[21], Is.EqualTo(0.5880485243048120).Within(0.05));
Assert.That(result[22], Is.EqualTo(0.5433842148912880).Within(0.05));
Assert.That(result[23], Is.EqualTo(0.5017780549216030).Within(0.05));
Assert.That(result[50], Is.EqualTo(0.0741442015957425).Within(0.009));
Assert.That(result[75], Is.EqualTo(0.0207568945092484).Within(0.006));
Assert.That(result[85], Is.EqualTo(0.0136661506653688).Within(0.006));
Assert.That(result[90], Is.EqualTo(0.0112550619601327).Within(0.006));
Assert.That(result[97], Is.EqualTo(0.0087026933539773).Within(0.005));
Assert.That(result[98], Is.EqualTo(0.0083995375385004).Within(0.005));
Assert.That(result[99], Is.EqualTo(0.0081094156379928).Within(0.005));
}
public async Task TestCauchyDistribution01()
{
// The properties of the cauchy distribution cannot be tested by mean, media or variance,
// cf. https://en.wikipedia.org/wiki/Cauchy_distribution#Explanation_of_undefined_moments
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.CauchyLorentzX1(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.009966272570142f).Within(0.003f));
Assert.That(result[1], Is.EqualTo(0.010168596941156f).Within(0.004f));
Assert.That(result[2], Is.EqualTo(0.010377123221893f).Within(0.005f));
Assert.That(result[21], Is.EqualTo(0.015956672819692f).Within(0.005f));
Assert.That(result[22], Is.EqualTo(0.016366904083094f).Within(0.005f));
Assert.That(result[23], Is.EqualTo(0.016793067514802f).Within(0.005f));
Assert.That(result[50], Is.EqualTo(0.039454644029179f).Within(0.015f));
Assert.That(result[75], Is.EqualTo(0.145970509936354f).Within(0.03f));
Assert.That(result[85], Is.EqualTo(0.333365083503296f).Within(0.1f));
Assert.That(result[90], Is.EqualTo(0.545171628270584f).Within(0.1f));
Assert.That(result[97], Is.EqualTo(0.948808314586302f).Within(0.06f));
Assert.That(result[98], Is.EqualTo(0.976990739772032f).Within(0.03f));
Assert.That(result[99], Is.EqualTo(0.986760647169751f).Within(0.02f));
}
public async Task TestStudentTDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.StudentTNu1(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.000000000).Within(0.2));
Assert.That(result[1], Is.EqualTo(0.999700120).Within(0.2));
Assert.That(result[2], Is.EqualTo(0.999200719).Within(0.2));
Assert.That(result[21], Is.EqualTo(0.953929798).Within(0.2));
Assert.That(result[22], Is.EqualTo(0.949852788).Within(0.2));
Assert.That(result[23], Is.EqualTo(0.945631619).Within(0.2));
Assert.That(result[50], Is.EqualTo(0.793667169).Within(0.095));
Assert.That(result[75], Is.EqualTo(0.633937627).Within(0.09));
Assert.That(result[85], Is.EqualTo(0.574902276).Within(0.09));
Assert.That(result[90], Is.EqualTo(0.547070729).Within(0.09));
Assert.That(result[97], Is.EqualTo(0.510150990).Within(0.09));
Assert.That(result[98], Is.EqualTo(0.505075501).Within(0.09));
Assert.That(result[99], Is.EqualTo(0.500050000).Within(0.09));
}
public async Task TestChiSquareDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.ChiSquareK10(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
var value = await dist.NextNumber();
fqa.CountThis(value);
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0000000164021588f).Within(0.0000002f));
Assert.That(result[1], Is.EqualTo(0.0000002611256437f).Within(0.000003f));
Assert.That(result[2], Is.EqualTo(0.0000013153553250f).Within(0.00002f));
Assert.That(result[21], Is.EqualTo(0.003459320622874f).Within(0.005f));
Assert.That(result[22], Is.EqualTo(0.004111875573379f).Within(0.005f));
Assert.That(result[23], Is.EqualTo(0.004850674298859f).Within(0.005f));
Assert.That(result[50], Is.EqualTo(0.086418773275056f).Within(0.05f));
Assert.That(result[75], Is.EqualTo(0.376092741436046f).Within(0.08f));
Assert.That(result[85], Is.EqualTo(0.586569751611096f).Within(0.08f));
Assert.That(result[90], Is.EqualTo(0.717189736168766f).Within(0.08f));
Assert.That(result[97], Is.EqualTo(0.931477764640217f).Within(0.08f));
Assert.That(result[98], Is.EqualTo(0.965244855212136f).Within(0.08f));
Assert.That(result[99], Is.EqualTo(0.999827884370044f).Within(0.08f));
}
public async Task TestBetaDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.BetaA2B2(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fqa.CountThis(await dist.NextNumber());
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0396).Within(0.3));
Assert.That(result[1], Is.EqualTo(0.0784).Within(0.3));
Assert.That(result[2], Is.EqualTo(0.1164).Within(0.3));
Assert.That(result[21], Is.EqualTo(0.6864).Within(0.3));
Assert.That(result[22], Is.EqualTo(0.7084).Within(0.3));
Assert.That(result[23], Is.EqualTo(0.7296).Within(0.3));
Assert.That(result[50], Is.EqualTo(0.9996).Within(0.3));
Assert.That(result[75], Is.EqualTo(0.7296).Within(0.3));
Assert.That(result[85], Is.EqualTo(0.4816).Within(0.3));
Assert.That(result[90], Is.EqualTo(0.3276).Within(0.3));
Assert.That(result[97], Is.EqualTo(0.0784).Within(0.3));
Assert.That(result[98], Is.EqualTo(0.0396).Within(0.3));
Assert.That(result[99], Is.EqualTo(0.0000).Within(0.3));
}
public async Task TestChiSquareDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.ChiSquareK1(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
var value = await dist.NextNumber();
fqa.CountThis(value);
}
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.00032041964207).Within(0.004));
Assert.That(result[1], Is.EqualTo(0.70380551227703).Within(0.05));
Assert.That(result[2], Is.EqualTo(0.571788691668126).Within(0.05));
Assert.That(result[21], Is.EqualTo(0.192011337664754).Within(0.07));
Assert.That(result[22], Is.EqualTo(0.186854182385981).Within(0.07));
Assert.That(result[23], Is.EqualTo(0.182007652359976).Within(0.07));
Assert.That(result[50], Is.EqualTo(0.109088865614875).Within(0.06));
Assert.That(result[75], Is.EqualTo(0.07886274821701).Within(0.02));
Assert.That(result[85], Is.EqualTo(0.070520397849883).Within(0.02));
Assert.That(result[90], Is.EqualTo(0.066863009640287).Within(0.02));
Assert.That(result[97], Is.EqualTo(0.062214737436948).Within(0.02));
Assert.That(result[98], Is.EqualTo(0.061590997922187).Within(0.02));
Assert.That(result[99], Is.EqualTo(0.060976622578824).Within(0.02));
}
public async Task TestWeibullDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Float.Distributions.WeibullK05La1(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(1.000000000f).Within(0.2f));
Assert.That(result[1], Is.EqualTo(0.678415772f).Within(0.09f));
Assert.That(result[2], Is.EqualTo(0.536595233f).Within(0.09f));
Assert.That(result[21], Is.EqualTo(0.147406264f).Within(0.02f));
Assert.That(result[22], Is.EqualTo(0.142654414f).Within(0.02f));
Assert.That(result[23], Is.EqualTo(0.138217760f).Within(0.02f));
Assert.That(result[50], Is.EqualTo(0.075769787f).Within(0.095f));
Assert.That(result[75], Is.EqualTo(0.053016799f).Within(0.05f));
Assert.That(result[85], Is.EqualTo(0.047144614f).Within(0.05f));
Assert.That(result[90], Is.EqualTo(0.044629109f).Within(0.05f));
Assert.That(result[97], Is.EqualTo(0.041484591f).Within(0.05f));
Assert.That(result[98], Is.EqualTo(0.041067125f).Within(0.05f));
Assert.That(result[99], Is.EqualTo(0.040656966f).Within(0.05f));
}
public async Task TestLaplaceDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.LaplaceB01M05(rng);
var fra = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
{
fra.CountThis(await dist.NextNumber());
}
var result = fra.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0074465830709244).Within(0.004));
Assert.That(result[1], Is.EqualTo(0.0082297470490200).Within(0.004));
Assert.That(result[2], Is.EqualTo(0.0090952771016958).Within(0.01));
Assert.That(result[21], Is.EqualTo(0.0608100626252180).Within(0.02));
Assert.That(result[22], Is.EqualTo(0.0672055127397498).Within(0.02));
Assert.That(result[23], Is.EqualTo(0.0742735782143340).Within(0.02));
Assert.That(result[50], Is.EqualTo(1.0000000000000000).Within(0.2));
Assert.That(result[75], Is.EqualTo(0.0742735782143335).Within(0.01));
Assert.That(result[85], Is.EqualTo(0.0273237224472924).Within(0.01));
Assert.That(result[90], Is.EqualTo(0.0165726754017612).Within(0.01));
Assert.That(result[97], Is.EqualTo(0.0082297470490200).Within(0.004));
Assert.That(result[98], Is.EqualTo(0.0074465830709243).Within(0.004));
Assert.That(result[99], Is.EqualTo(0.0067379469990854).Within(0.004));
}
public async Task TestExponentialDistribution01()
{
using var rng = new MultiThreadedRng();
var dist = new FastRng.Double.Distributions.InverseExponentialLa10(rng);
var fqa = new FrequencyAnalysis();
for (var n = 0; n < 100_000; n++)
fqa.CountThis(await dist.NextNumber());
var result = fqa.NormalizeAndPlotEvents(TestContext.WriteLine);
Assert.That(result[0], Is.EqualTo(0.0000501746820562).Within(0.0003));
Assert.That(result[1], Is.EqualTo(0.0000554515994322).Within(0.0003));
Assert.That(result[2], Is.EqualTo(0.0000612834950532).Within(0.0003));
Assert.That(result[21], Is.EqualTo(0.00040973497898).Within(0.00045));
Assert.That(result[22], Is.EqualTo(0.000452827182887).Within(0.00050));
Assert.That(result[23], Is.EqualTo(0.000500451433441).Within(0.00051));
Assert.That(result[50], Is.EqualTo(0.007446583070924).Within(0.003));
Assert.That(result[75], Is.EqualTo(0.090717953289412).Within(0.02));
Assert.That(result[85], Is.EqualTo(0.246596963941606).Within(0.05));
Assert.That(result[90], Is.EqualTo(0.406569659740598).Within(0.08));
Assert.That(result[97], Is.EqualTo(0.81873075307798).Within(0.08));
Assert.That(result[98], Is.EqualTo(0.904837418035957).Within(0.08));
Assert.That(result[99], Is.EqualTo(0.999999999999999).Within(0.08));
}
public void Compare_Opposite()
{
var result = FrequencyAnalysis.Compare(
new Dictionary <char, double>
{
{ 'A', 0.2 },
{ 'B', 0.8 },
},
new Dictionary <char, double>
{
{ 'C', 0.3 },
{ 'D', 0.7 },
}
);
Assert.AreEqual(0, result);
}
public void FreqGeneratesCorrectly()
{
var bytes = Encoding.ASCII.GetBytes(THE_QBF);
var freq = new FrequencyAnalysis(bytes, FreqTableType.AlphaOnly);
var list = freq.GetFrequencyCounts().ToArray();
Assert.AreEqual(1, list[97], "# A incorrect");
Assert.AreEqual(4, list[111], "# O incorrect");
var vals = list.Where(n => n > 0).ToArray();
CollectionAssert.AreEqual(QBF_COUNTS, vals, "Final counts are incorrect");
double letterAPct = freq.GetFrequencyPctByChar('a');
double letterAPct2 = freq.GetFrequencyPctByChar('A');
Assert.AreEqual(letterAPct, letterAPct2, "Letter A and letter a not equal");
Assert.AreEqual(Math.Round(100.0 / (double)THE_QBF.Length, 5), letterAPct, "Letter A not 1/43 freq");
}
public void Compare_Identical()
{
var result = FrequencyAnalysis.Compare(
new Dictionary <char, double>
{
{ 'A', 0.2 },
{ 'B', 0.5 },
{ 'C', 0.3 },
},
new Dictionary <char, double>
{
{ 'A', 0.2 },
{ 'B', 0.5 },
{ 'C', 0.3 },
}
);
Assert.AreEqual(1, result);
}
public static List <Hashtable> AboutPerson(string name, int quantity)
{
// Grab test data
List <Hashtable> training_data = new List <Hashtable>();
for (int i = 1; i < quantity + 1; i++)
{
string data = File.ReadAllText("../../Corpus/" + SanitizeName(name) + "-" + i + ".txt");
training_data.Add(new Hashtable()
{
{ "Vowel Frequency", FrequencyAnalysis.VowelFrequency(data) },
{ "Consonant Frequency", FrequencyAnalysis.ConsonantFrequency(data) },
{ "Digit Frequency", FrequencyAnalysis.DigitFrequency(data) },
{ "Punctuation Frequency", FrequencyAnalysis.PunctuationFrequency(data) },
{ "Spacing Frequency", FrequencyAnalysis.SpacingFrequency(data) },
{ "Special Character Frequency", FrequencyAnalysis.SpecialCharacterFrequency(data) },
{ "Word Count", FrequencyAnalysis.WordCount(data) },
{ "Characters Per Word", FrequencyAnalysis.CharactersPerWord(data) },
{ "Words Per Sentence", FrequencyAnalysis.WordsPerSentence(data) },
{ "Preposition Frequency", FrequencyAnalysis.PrepositionFrequency(data) },
{ "Pronoun Frequency", FrequencyAnalysis.PronounFrequency(data) },
{ "Determiner Frequency", FrequencyAnalysis.DeterminerFrequency(data) },
{ "Conjunction Frequency", FrequencyAnalysis.ConjunctionFrequency(data) },
{ "Attribution Frequency", FrequencyAnalysis.AttributionFrequency(data) },
{ "Link Frequency", FrequencyAnalysis.LinkFrequency(data) },
{ "1-letter Words", FrequencyAnalysis.WordsOfLength(1, 1, data) },
{ "2-letter Words", FrequencyAnalysis.WordsOfLength(2, 2, data) },
{ "3-letter Words", FrequencyAnalysis.WordsOfLength(3, 3, data) },
{ "4-letter Words", FrequencyAnalysis.WordsOfLength(4, 4, data) },
{ "5-letter Words", FrequencyAnalysis.WordsOfLength(5, 5, data) },
{ "6-letter Words", FrequencyAnalysis.WordsOfLength(6, 6, data) },
{ "7-letter Words", FrequencyAnalysis.WordsOfLength(7, 7, data) },
{ "8-10-letter Words", FrequencyAnalysis.WordsOfLength(8, 10, data) },
{ "11-20-letter Words", FrequencyAnalysis.WordsOfLength(11, 20, data) }
});
}
return(training_data);
}
public static byte[] Encode(byte[] data)
{
FrequencyAnalysis frequencyAnalysis = new FrequencyAnalysis(data);
return(data);
}
public void DeleteAnalysis(FrequencyAnalysis analysis)
{
FrequencyAnalysis.Remove(analysis);
context.SaveChanges();
}
public static void Main()
{
// 2 variables to store path of file and txt in that file
string path, text;
// Keep prompting the user for the path if he/she doesn't co-operate
do
{
Console.Write("The file's path: ");
path = Console.ReadLine();
}
while (string.IsNullOrEmpty(path?.Trim()));
// Check if the path is valid or invalid
try
{
// Store the text in the file if the path is VALID
text = File.ReadAllText(path);
}
catch (Exception)
{
// Display useful messages and exit if the path is INVALID
Console.WriteLine("FILE DOES NOT EXIST !");
Console.WriteLine("-> please enter the file's full path");
return;
}
// Store the number of letters/words/sentences in text in their variables
var numberOfLetters = BasicAnalysis.CharacterCounter(text.Trim());
var numberOfWords = BasicAnalysis.WordCounter(text.Trim());
var numberOfSentences = BasicAnalysis.SentenceCounter(text.Trim());
// Store the average number of letters\sentences per 100 words
var averageNumberOfLetters = (int) Math.Round(ReadabilityAnalysis.LettersAverageNumber(numberOfLetters, numberOfWords));
var averageNumberOfSentences = (int) Math.Round(ReadabilityAnalysis.SentencesAverageNumber(numberOfSentences, numberOfWords));
// Populate the array with the number of times the alphabets have shown in text
for (var i = 0; i < Globals.AlphabetArray.Length; i++)
{
Globals.AlphabetFrequencies[i] = FrequencyAnalysis.Frequency(text, Globals.AlphabetArray[i]);
}
// Store the frequency of the letter that has appeared in text only
/* It's max size is 26 because it won't store more than the alphabets */
var frequencies = new int[Globals.Alphabet];
// Store frequency's percentage of letter that has appeared in text
/* It's with max size 26 because it won't store more than the alphabets */
var frequenciesPercentage = new float[Globals.Alphabet];
// Iterate over the array stored the frequencies of all alphabets
for (var i = 0; i < Globals.AlphabetFrequencies.Length; i++)
{
// Check if the letter has appeared at least one in text
if (Globals.AlphabetFrequencies[i] > 0)
{
// Populate "frequencies" array with that letter's frequency
frequencies[i] = Globals.AlphabetFrequencies[i];
// Populate "frequenciesPercentage" array with that letter's frequency percentage
frequenciesPercentage[i] = FrequencyAnalysis.FrequencyPercentage(text, Globals.AlphabetArray[i]);
// Print the frequency, frequency percentage and histogram to console
Console.Write("Frequency of {0}: {1:F}%\t", Globals.AlphabetArray[i], frequenciesPercentage[i]);
FrequencyAnalysis.HistogramDrawer(text, Globals.AlphabetArray[i]);
Console.WriteLine();
}
}
// Display the readability of the text
ReadabilityAnalysis.Readability(averageNumberOfLetters, averageNumberOfSentences);
// Display the Most frequently used word
Console.WriteLine("The most frequently used word is: " + AdvancedAnalysis.MostFrequentlyUsedWord(text));
}
