Imagine you are playing poker, you’re making use of the Kelly Criterion to calculate the optimal limit of your betting. You’re also using something to evaluate what your chances of winning are. But being poker, there are several rounds of betting so how much of your Kelly Limit should you bet per round?

Should you bet everything all at once and hope to knock other players out or should you bet slowly to draw other players in? How aggressive should your betting style be?

We need a function that accumulates to 1 but also varies it’s peak as a variable (let’s call it k) representing the number of betting rounds increases.

One function that matches these requirement is the Poisson distribution http://en.wikipedia.org/wiki/Poisson_distribution

So here’s the code for that:

```
public class PoissonEvaluator
{
decimal lambda;
public PoissonEvaluator(decimal lambda = 1.0M)
{
this.lambda = lambda;
}
public decimal ProbabilityMassFunction(int k)
{
//(l^k / k! ) * e^-l
//l = lamda
int kFactorial = Factorial(k);
double numerator = Math.Pow(Math.E, -(double)lambda) * Math.Pow((double)lambda, (double)k);
decimal p = (decimal)numerator / kFactorial;
return p;
}
public decimal CummulitiveDistributionFunction(int k)
{
double e = Math.Pow(Math.E, (double)-lambda);
int i = 0;
double sum=0.0;
while (i <= k)
{
double n = Math.Pow((double)lambda, i) / Factorial(i);
sum += n;
i++;
}
decimal cdf = (decimal)e * (decimal)sum;
return cdf;
}
private int Factorial(int k)
{
int count = k;
int factorial = 1;
while (count >= 1)
{
factorial = factorial * count;
count–;
}
return factorial;
}
}
```