private int GetNumberOfOrders()
{
PoissonDistribution pd = new PoissonDistribution(2.7);
Dictionary <int, int> map = new Dictionary <int, int>();
for (int i = 0; i < 1000; i++)
{
int num = pd.Generate();
if (!map.ContainsKey(num))
{
map[num] = 0;
}
map[num]++;
}
return(pd.Generate());
}
public void GenerateTest()
{
double lambda = 1.11022302462516E-16;
var target = new PoissonDistribution(lambda) as ISampleableDistribution <double>;
double[] values = target.Generate(samples: 10000);
for (int i = 0; i < values.Length; i++)
{
Assert.AreEqual(0, values[i]);
}
}
public void GenerateTest3()
{
double lambda = 0.75;
var a = new PoissonDistribution(lambda) as ISampleableDistribution <double>;
Accord.Math.Random.Generator.Seed = 0;
double[] expected = a.Generate(samples: 10000);
Accord.Math.Random.Generator.Seed = 0;
var b = new PoissonDistribution(lambda);
Accord.Math.Random.Generator.Seed = 0;
int[] actual = b.Generate(10000);
Assert.IsTrue(expected.IsEqual(actual));
}
public static void PlayFixture(Club home, Club away)
{
// Get lambda value for both teams
double homeLambda = home.HomeAttackStrength * away.AwayDefenseStrength * _homegoalsavg;
double awayLambda = away.AwayAttackStrength * home.HomeDefenseStrength * _awaygoalsavg;
var poissonHome = new PoissonDistribution(homeLambda);
var poissonAway = new PoissonDistribution(awayLambda);
// Determine number of goals each team scored
int homeGoals = poissonHome.Generate();
int awayGoals = poissonAway.Generate();
// Record game results
home.GoalsFor += homeGoals;
away.GoalsFor += awayGoals;
home.GoalsAgainst += awayGoals;
away.GoalsAgainst += homeGoals;
if (homeGoals > awayGoals)
{
home.Wins++;
home.Points += 3;
away.Losses++;
}
else if (awayGoals > homeGoals)
{
home.Losses++;
away.Wins++;
away.Points += 3;
}
else
{
home.Draws++;
away.Draws++;
home.Points++;
away.Points++;
}
}
public void RankDistribution()
{
// Create a new distribution, such as a Poisson
var poisson = new PoissonDistribution(lambda: 0.42);
// Draw enough samples from it
double[] samples = poisson.Generate(1000000).ToDouble();
// Let's pretend we don't know from which distribution
// those sample come from, and create an analysis object
// to check it for us:
var analysis = new DistributionAnalysis();
// Compute the analysis
var gof = analysis.Learn(samples);
// Get the most likely distribution
var mostLikely = gof[0];
// The result should be Poisson(x; λ = 0.420961)
var result = (mostLikely.Distribution as IFormattable).ToString("N3", CultureInfo.InvariantCulture);
Assert.AreEqual("Poisson(x; λ = 0.422)", result);
}
public void RankDistribution()
{
// Create a new distribution, such as a Poisson
var poisson = new PoissonDistribution(lambda: 0.42);
// Draw enough samples from it
double[] samples = poisson.Generate(1000000).ToDouble();
// Let's pretend we don't know from which distribution
// those sample come from, and create an analysis object
// to check it for us:
var analysis = new DistributionAnalysis(samples);
// Compute the analysis
analysis.Compute();
// Get the most likely distribution
var mostLikely = analysis.GoodnessOfFit[0];
// The result should be Poisson(x; λ = 0.420961)
var result = mostLikely.Distribution.ToString();
Assert.AreEqual("Poisson(x; λ = 0.420961)", result);
}
public void Generate(int numColors, int samplesPerTile, int numThreads )
{
random = new Random();
this.numColors = numColors;
tiles = new List<WangTile>();
const int numEdges = 4;
int numTiles = (int)Math.Pow(numColors, numEdges);
#region generate Poisson distributions
List<PoissonSample>[] distributions = new List<PoissonSample>[numTiles];
generatePoissonDistParam_t[] threadParams = new generatePoissonDistParam_t[numThreads];
PoissonDistribution[] generators = new PoissonDistribution[numThreads];
AutoResetEvent[] waitHandles = new AutoResetEvent[numThreads];
for (int i = 0; i < numThreads; i++)
{
threadParams[i].dist = new PoissonDistribution();
threadParams[i].numSamples = samplesPerTile;
waitHandles[i] = new AutoResetEvent(false);
threadParams[i].autoResetEvent = waitHandles[i];
}
int t = 0;
Queue<int> availableThreads = new Queue<int>();
for (int i = 0; i < numThreads; i++) availableThreads.Enqueue(i);
if (OnConsoleMessage != null) OnConsoleMessage("Generating " + numTiles + " source Poisson Distributions with " + samplesPerTile + " samples each...");
Image debugImage = null;
if (OnDebugStep != null) debugImage = new Bitmap(800, 800);
while (t < numTiles || availableThreads.Count < numThreads)
{
while (availableThreads.Count > 0 && t < numTiles)
{
int i = availableThreads.Dequeue();
if (OnProgressReport != null) OnProgressReport((float)(t + 1) / numTiles);
distributions[t] = new List<PoissonSample>(samplesPerTile);
threadParams[i].result = distributions[t];
ThreadPool.QueueUserWorkItem(new WaitCallback(GeneratePoissonDistThreaded), threadParams[i]);
t++;
}
int index = WaitHandle.WaitAny(waitHandles);
if (debugImage != null)
{
PoissonDistribution.ToImage( threadParams[index].dist.Samples, Color.Black, debugImage, 1);
OnDebugStep(debugImage, "Poisson Distribution " + t);
}
availableThreads.Enqueue(index);
}
#endregion
#region generate seam tiles
List<SourceTile> seamTiles = new List<SourceTile>();
#if DEBUG
Color[] colors = new Color[numColors];
for( int i = 0; i < numColors; i++ ) colors[i] = Color.FromArgb(random.Next(256), random.Next(256), random.Next(256));
#endif
for (int i = 0; i < numColors; i++)
{
PoissonDistribution distribution = new PoissonDistribution();
distribution.Generate(samplesPerTile);
#if DEBUG
foreach (PoissonSample p in distribution.Samples) p.color = colors[i];
#endif
seamTiles.Add(new SourceTile(distribution.Samples, i));
}
#endregion
#region generate all edge permutations
/*
* 0000 0001 0002 ... 000n
* 0010 0011 0012 ... 001n
* 0020 0021 0022 ... 002n
* ...
* 00n0 00n1 00n2 ... 00nn
*
* 0100 0101 0102 ... 010n
* 0110 0111 0112 ... 011n
* ...
* 01n0 01n1 01n2 ... 01nn
*
* ...
*
* nnn0 nnn1 nnn2 ... nnnn
*/
int[,] edgeCol = new int[numTiles,numEdges];
for (int i = 0; i < numEdges; i++) edgeCol[0, i] = 0;
for (int i = 1; i < numTiles; i++)
{
for (int j = 0; j < numEdges; j++)
{
edgeCol[i,j] = (edgeCol[i-1,j] + (i % (int)Math.Pow(numColors, j) == 0 ? 1 : 0)) % numColors;
}
}
#endregion
#region generate wang tiles
WangTile[] tileArray = new WangTile[numTiles];
t = 0;
availableThreads.Clear();
createWangTileParam_t[] createWangTileParams = new createWangTileParam_t[numThreads];
for (int i = 0; i < numThreads; i++)
{
availableThreads.Enqueue(i);
createWangTileParams[i] = new createWangTileParam_t();
createWangTileParams[i].autoResetEvent = waitHandles[i];
createWangTileParams[i].autoResetEvent.Reset();
createWangTileParams[i].tileArray = tileArray;
}
if (OnConsoleMessage != null) OnConsoleMessage("Merging distributions to generate Wang Tiles..." );
while (t < numTiles || availableThreads.Count < numThreads)
{
while (availableThreads.Count > 0 && t < numTiles)
{
int i = availableThreads.Dequeue();
if (OnProgressReport != null) OnProgressReport((float)( t + 1 ) / numTiles);
createWangTileParams[i].tileBaseDistribution = distributions[t];
createWangTileParams[i].neighbours = new List<SourceTile>();
createWangTileParams[i].tileIndex = t;
if (numColors > 1)
{
for (int j = 0; j < numEdges; j++)
createWangTileParams[i].neighbours.Add(seamTiles[edgeCol[t, j]]);
}
ThreadPool.QueueUserWorkItem(new WaitCallback(CreateWangTileThreaded), createWangTileParams[i]);
t++;
}
int index = WaitHandle.WaitAny(waitHandles);
availableThreads.Enqueue(index);
}
tiles = tileArray.ToList();
SortTiles();
MakeRecursive();
if (OnDebugStep != null)
{
ToColorTiles(debugImage, new Size(8, 8));
OnDebugStep(debugImage, "Sample coverage of the generated Wang Tiles" );
}
#endregion
}
public void Generate(int numColors, int samplesPerTile, int numThreads)
{
random = new Random();
this.numColors = numColors;
tiles = new List <WangTile>();
const int numEdges = 4;
int numTiles = (int)Math.Pow(numColors, numEdges);
#region generate Poisson distributions
List <PoissonSample>[] distributions = new List <PoissonSample> [numTiles];
generatePoissonDistParam_t[] threadParams = new generatePoissonDistParam_t[numThreads];
PoissonDistribution[] generators = new PoissonDistribution[numThreads];
AutoResetEvent[] waitHandles = new AutoResetEvent[numThreads];
for (int i = 0; i < numThreads; i++)
{
threadParams[i].dist = new PoissonDistribution();
threadParams[i].numSamples = samplesPerTile;
waitHandles[i] = new AutoResetEvent(false);
threadParams[i].autoResetEvent = waitHandles[i];
}
int t = 0;
Queue <int> availableThreads = new Queue <int>();
for (int i = 0; i < numThreads; i++)
{
availableThreads.Enqueue(i);
}
if (OnConsoleMessage != null)
{
OnConsoleMessage("Generating " + numTiles + " source Poisson Distributions with " + samplesPerTile + " samples each...");
}
Image debugImage = null;
if (OnDebugStep != null)
{
debugImage = new Bitmap(800, 800);
}
while (t < numTiles || availableThreads.Count < numThreads)
{
while (availableThreads.Count > 0 && t < numTiles)
{
int i = availableThreads.Dequeue();
if (OnProgressReport != null)
{
OnProgressReport((float)(t + 1) / numTiles);
}
distributions[t] = new List <PoissonSample>(samplesPerTile);
threadParams[i].result = distributions[t];
ThreadPool.QueueUserWorkItem(new WaitCallback(GeneratePoissonDistThreaded), threadParams[i]);
t++;
}
int index = WaitHandle.WaitAny(waitHandles);
if (debugImage != null)
{
PoissonDistribution.ToImage(threadParams[index].dist.Samples, Color.Black, debugImage, 1);
OnDebugStep(debugImage, "Poisson Distribution " + t);
}
availableThreads.Enqueue(index);
}
#endregion
#region generate seam tiles
List <SourceTile> seamTiles = new List <SourceTile>();
#if DEBUG
Color[] colors = new Color[numColors];
for (int i = 0; i < numColors; i++)
{
colors[i] = Color.FromArgb(random.Next(256), random.Next(256), random.Next(256));
}
#endif
for (int i = 0; i < numColors; i++)
{
PoissonDistribution distribution = new PoissonDistribution();
distribution.Generate(samplesPerTile);
#if DEBUG
foreach (PoissonSample p in distribution.Samples)
{
p.color = colors[i];
}
#endif
seamTiles.Add(new SourceTile(distribution.Samples, i));
}
#endregion
#region generate all edge permutations
/*
* 0000 0001 0002 ... 000n
* 0010 0011 0012 ... 001n
* 0020 0021 0022 ... 002n
* ...
* 00n0 00n1 00n2 ... 00nn
*
* 0100 0101 0102 ... 010n
* 0110 0111 0112 ... 011n
* ...
* 01n0 01n1 01n2 ... 01nn
*
* ...
*
* nnn0 nnn1 nnn2 ... nnnn
*/
int[,] edgeCol = new int[numTiles, numEdges];
for (int i = 0; i < numEdges; i++)
{
edgeCol[0, i] = 0;
}
for (int i = 1; i < numTiles; i++)
{
for (int j = 0; j < numEdges; j++)
{
edgeCol[i, j] = (edgeCol[i - 1, j] + (i % (int)Math.Pow(numColors, j) == 0 ? 1 : 0)) % numColors;
}
}
#endregion
#region generate wang tiles
WangTile[] tileArray = new WangTile[numTiles];
t = 0;
availableThreads.Clear();
createWangTileParam_t[] createWangTileParams = new createWangTileParam_t[numThreads];
for (int i = 0; i < numThreads; i++)
{
availableThreads.Enqueue(i);
createWangTileParams[i] = new createWangTileParam_t();
createWangTileParams[i].autoResetEvent = waitHandles[i];
createWangTileParams[i].autoResetEvent.Reset();
createWangTileParams[i].tileArray = tileArray;
}
if (OnConsoleMessage != null)
{
OnConsoleMessage("Merging distributions to generate Wang Tiles...");
}
while (t < numTiles || availableThreads.Count < numThreads)
{
while (availableThreads.Count > 0 && t < numTiles)
{
int i = availableThreads.Dequeue();
if (OnProgressReport != null)
{
OnProgressReport((float)(t + 1) / numTiles);
}
createWangTileParams[i].tileBaseDistribution = distributions[t];
createWangTileParams[i].neighbours = new List <SourceTile>();
createWangTileParams[i].tileIndex = t;
if (numColors > 1)
{
for (int j = 0; j < numEdges; j++)
{
createWangTileParams[i].neighbours.Add(seamTiles[edgeCol[t, j]]);
}
}
ThreadPool.QueueUserWorkItem(new WaitCallback(CreateWangTileThreaded), createWangTileParams[i]);
t++;
}
int index = WaitHandle.WaitAny(waitHandles);
availableThreads.Enqueue(index);
}
tiles = tileArray.ToList();
SortTiles();
MakeRecursive();
if (OnDebugStep != null)
{
ToColorTiles(debugImage, new Size(8, 8));
OnDebugStep(debugImage, "Sample coverage of the generated Wang Tiles");
}
#endregion
}
private void testBtn_Click(object sender, EventArgs e)
{
double alpha = (double)alphaNumeric.Value;
double opgBorder = Math.Sqrt(-Math.Log((alpha) / 2) / 2);
opgLbl.Text = "(0; " + opgBorder.ToString() + ")";
IRandomNumberGenerator <double> generator;
switch (_transferData.Distribution)
{
case DistributionEnum.Uniform:
{
generator = new UniformContinuousDistribution(_transferData.A, _transferData.B);
break;
}
case DistributionEnum.Exponential:
{
generator = new ExponentialDistribution(_transferData.Lambda);
break;
}
case DistributionEnum.Erlang:
{
generator = new ErlangDistribution(_transferData.Lambda, _transferData.N);
break;
}
case DistributionEnum.Normal:
{
generator = new NormalDistribution(_transferData.Mu, _transferData.Sigma);
break;
}
case DistributionEnum.Poisson:
{
generator = new PoissonDistribution(_transferData.Lambda);
break;
}
default: return;
}
List <double> newGenerated = generator.Generate(_transferData.Numbers.Count).ToList();
newGenerated.Sort();
exStatNumPg.NumberList = newGenerated;
exNLbl.Text = newGenerated.Count.ToString();
exMinLbl.Text = newGenerated.Min().ToString();
exMaxLbl.Text = newGenerated.Max().ToString();
exMeanLbl.Text = newGenerated.Average().ToString();
double average = newGenerated.Average();
exStdDevLbl.Text = Math.Sqrt(
newGenerated.Sum((num) => { return(Math.Pow(num - average, 2)); })
/ newGenerated.Count)
.ToString();
double KS = GetKolmogorovSmirnov(newGenerated);
ksLbl.Text = KS.ToString();
}
