public void PoissonBug()
{
PoissonDistribution pd = new PoissonDistribution(0.5);
double x = pd.InverseLeftProbability(0.7716);
Console.WriteLine(x);
}
public void InverseDistributionFunctionTest()
{
// Create a new Poisson distribution
var dist = new PoissonDistribution(lambda: 2);
double equal = dist.ProbabilityMassFunction(k: 7);
double lte1 = dist.DistributionFunction(k: 7);
double lte2 = dist.DistributionFunction(k: 7, inclusive: true);
double less = dist.DistributionFunction(k: 7, inclusive: false);
double inv0 = dist.InverseDistributionFunction(0.99890328103214132);
double inv1 = dist.InverseDistributionFunction(lte1);
double inv2 = dist.InverseDistributionFunction(lte2);
double inv3 = dist.InverseDistributionFunction(less);
Assert.AreEqual(equal, 0.0034370865583901638, 1e-10);
Assert.AreEqual(less, 0.99546619447375118, 1e-10);
Assert.AreEqual(lte1, 0.99890328103214132, 1e-10);
Assert.AreEqual(lte2, 0.99890328103214132, 1e-10);
Assert.AreEqual(inv0, 7, 1e-10);
Assert.AreEqual(inv1, 7, 1e-10);
Assert.AreEqual(inv2, 7, 1e-10);
Assert.AreEqual(inv3, 6, 1e-10);
}
public void DistributionFunctionTest()
{
// Create a new Poisson distribution
var dist = new PoissonDistribution(lambda: 4.2);
// P(X = 1) = 0.0629814226460064
double equal = dist.ProbabilityMassFunction(k: 1);
// P(X < 1) = 0.0149955768204777
double less = dist.DistributionFunction(k: 1, inclusive: false);
// P(X ≤ 1) = 0.0779769994664841
double lessThanOrEqual = dist.DistributionFunction(k: 1, inclusive: true);
// P(X > 1) = 0.922023000533516
double greater = dist.ComplementaryDistributionFunction(k: 1);
// P(X ≥ 1) = 0.985004423179522
double greaterThanOrEqual = dist.ComplementaryDistributionFunction(k: 1, inclusive: true);
Assert.AreEqual(equal, 0.0629814226460064, 1e-10);
Assert.AreEqual(less, 0.0149955768204777, 1e-10);
Assert.AreEqual(lessThanOrEqual, 0.0779769994664841, 1e-10);
Assert.AreEqual(greater, 0.922023000533516, 1e-10);
Assert.AreEqual(greaterThanOrEqual, 0.985004423179522, 1e-10);
}
//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);
}
/*
* minValue: es el minimo de personas que llegan al andén
* maxValue: es el máximo de personas que llegan al andén
* personasPorMinuto: cantida de personas que llegan por minuto
* cantidadEnHoras: tiempo en horas de la muestra de personas
*/
public static int Poisson(int minValue, int maxValue, int personasPorMinuto, int cantidadEnHoras)
{
double r1, r2, m, y, fx;
int k, lambda, x;
if ((personasPorMinuto <= 0) || (cantidadEnHoras <= 0))
{
throw new System.ArgumentException("Valores incorrectos");
}
k = personasPorMinuto;
lambda = cantidadEnHoras;
PoissonDistribution f = new PoissonDistribution(lambda);
m = Math.Pow(k, k) / (Math.Exp(k) * AdvancedIntegerMath.Factorial(k));
Random r = new Random();
do
{
r1 = r.NextDouble();
r2 = r.NextDouble();
x = Convert.ToInt32(minValue + (maxValue - minValue) * r1);
y = m * r2;
fx = f.ProbabilityMass(Convert.ToInt32(k * r1));
} while (y < fx);
return(x);
}
void Poisson(Texture2D worldMap)
{
Debug.Log("Starting Poisson...");
long time = DateTime.Now.Ticks;
PoissonDistribution dist = new PoissonDistribution((x, z, v) =>
worldMap.GetPixel((int)x, (int)z).r < 0.22f ? (
v < 0.95f ? v * 0.01f : 0.4f
) : 1.0f
);
List <Vector3> poissonMap = PoissonGenerator.GeneratePoisson(Constants.WorldSize, Constants.WorldSize, 4.25f, 30.0f, dist, 90);
Color[] colorSet = new Color[(Constants.WorldSize) * (Constants.WorldSize)];
for (int i = 0; i < colorSet.Length; i++)
{
colorSet[i] = new Color(0, 0, 0, 0);
}
detailMap.SetPixels(colorSet);
detailMap.Apply();
foreach (Vector3 v in poissonMap)
{
float val = (v.z - 3.0f) / 30.0f;
detailMap.SetPixel((int)v.x, (int)v.y, new Color(val, 0, val));
}
detailMap.Apply();
byte[] bytes = detailMap.EncodeToPNG();
File.WriteAllBytes(Application.dataPath + "/../Poisson.png", bytes);
float seconds = (DateTime.Now.Ticks - time) / 10000000.0f;
Debug.Log("Poisson finished in " + seconds + " seconds!");
}
protected override void EndProcessing()
{
var dist = new PoissonDistribution(Lambda);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void ConstructorTest2()
{
// Create a new Poisson distribution with lambda = 0.7
PoissonDistribution poisson = new PoissonDistribution(0.7);
double mean = poisson.Mean; // 0.7 (lambda)
double median = poisson.Median; // 1.0
double mode = poisson.Mode; // 0.7 (lambda)
double stdDev = poisson.StandardDeviation; // 0.836 [sqrt((lambda))]
double var = poisson.Variance; // 0.7 (lambda)
// The cumulative distribution function, or the probability that a real-valued
// random variable will be found to have a value less than or equal to some x:
double cdf = poisson.DistributionFunction(k: 1); // 0.84419501644539618
// The probability density function, or the relative likelihood for a real-valued
// random variable will be found to take on a given specific value of x:
double pdf = poisson.ProbabilityMassFunction(k: 1); // 0.34760971265398666
// The log of the probability density function, useful for applications where
// precision is critical
double lpdf = poisson.LogProbabilityMassFunction(k: 1); // -1.0566749439387324
// The complementary distribution function, or the tail function, that gives the
// probability that a real-valued random variable will be found to have a value
// greater than some x. This function is also known as the Survival function.
double ccdf = poisson.ComplementaryDistributionFunction(k: 1); // 0.15580498355460382
// The inverse distribution function, or the Quantile function, that is able to
// revert probability values back to the real value that produces that probability
int icdf = poisson.InverseDistributionFunction(p: cdf); // 1
// The Hazard function, or the failure rate, the event rate at time t conditional
// on survival until time t or later. Note that this function may only make sense
// when using time-defined distributions, such as the Poisson.
double hf = poisson.HazardFunction(x: 1); // 2.2310564445595058
// The cumulative hazard function, that gives how much the hazard
// function accumulated over time until a given time instant x.
double chf = poisson.CumulativeHazardFunction(x: 1); // 1.8591501591854034
// Every distribution has a friendly string representation
string str = poisson.ToString(System.Globalization.CultureInfo.InvariantCulture); // Poisson(x; λ = 0.7)
Assert.AreEqual(0.84419501644539618, cdf);
Assert.AreEqual(0.34760971265398666, pdf);
Assert.AreEqual(-1.0566749439387324, lpdf);
Assert.AreEqual(0.15580498355460382, ccdf);
Assert.AreEqual(1, icdf);
Assert.AreEqual(2.2310564445595058, hf);
Assert.AreEqual(1.8591501591854034, chf);
Assert.AreEqual("Poisson(x; λ = 0.7)", str);
Assert.AreEqual(0.7, mean);
Assert.AreEqual(0.7, mode);
Assert.AreEqual(1, median);
Assert.AreEqual(0.7, var);
Assert.AreEqual(0.83666002653407556, stdDev);
}
public void MedianTest()
{
for (int i = 0; i < 25; i++)
{
var target = new PoissonDistribution(i + 1);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
public void ProbabilityDensityFunctionTest()
{
PoissonDistribution target = new PoissonDistribution(25);
double actual = target.ProbabilityMassFunction(20);
double expected = 0.051917468608491321;
Assert.AreEqual(expected, actual);
}
public void LogProbabilityDensityFunctionTest()
{
PoissonDistribution target = new PoissonDistribution(25);
double actual = target.LogProbabilityMassFunction(20);
double expected = System.Math.Log(0.051917468608491321);
Assert.AreEqual(expected, actual, 1e-10);
}
/// <summary>
/// Metodo que calcula la frecuencia esperada en un intervalo
/// </summary>
/// <param name="intervalo"></param>
/// <param name="tamanioMuestra"></param>
/// <param name="cantidadIntervalos"></param>
/// <returns></returns>
public override double CalcularFrecuenciaEsperadaEnIntervalo(Intervalo intervalo, int tamanioMuestra, int cantidadIntervalos = 0)
{
var distribucion = new PoissonDistribution(Lambda);
var probabilidadEsperada = distribucion.LeftExclusiveProbability((int)intervalo.LimiteSuperior) -
distribucion.LeftExclusiveProbability((int)intervalo.LimiteInferior);
return(probabilidadEsperada * tamanioMuestra);
}
public void ConstructorTest()
{
// Create a new Poisson distribution with
var dist = new PoissonDistribution(lambda: 4.2);
// Common measures
double mean = dist.Mean; // 4.2
double median = dist.Median; // 4.0
double var = dist.Variance; // 4.2
// Cumulative distribution functions
double cdf = dist.DistributionFunction(k: 2); // 0.39488100648845126
double ccdf = dist.ComplementaryDistributionFunction(k: 2); // 0.60511899351154874
// Probability mass functions
double pmf1 = dist.ProbabilityMassFunction(k: 4); // 0.19442365170822165
double pmf2 = dist.ProbabilityMassFunction(k: 5); // 0.1633158674349062
double pmf3 = dist.ProbabilityMassFunction(k: 6); // 0.11432110720443435
double lpmf = dist.LogProbabilityMassFunction(k: 2); // -2.0229781299813
// Quantile function
int icdf1 = dist.InverseDistributionFunction(p: 0.17); // 2
int icdf2 = dist.InverseDistributionFunction(p: 0.46); // 4
int icdf3 = dist.InverseDistributionFunction(p: 0.87); // 7
// Hazard (failure rate) functions
double hf = dist.HazardFunction(x: 4); // 0.19780423301883465
double chf = dist.CumulativeHazardFunction(x: 4); // 0.017238269667812049
// String representation
string str = dist.ToString(CultureInfo.InvariantCulture); // "Poisson(x; λ = 4.2)"
// Median bounds
// (http://en.wikipedia.org/wiki/Poisson_distribution#Median)
Assert.IsTrue(median < 4.2 + 1 / 3.0);
Assert.IsTrue(4.2 - System.Math.Log(2) <= median);
Assert.AreEqual(4.2, mean);
Assert.AreEqual(4.0, median);
Assert.AreEqual(4.2, var);
Assert.AreEqual(0.017238269667812049, chf, 1e-10);
Assert.AreEqual(0.39488100648845126, cdf);
Assert.AreEqual(0.19442365170822165, pmf1);
Assert.AreEqual(0.1633158674349062, pmf2);
Assert.AreEqual(0.11432110720443435, pmf3);
Assert.AreEqual(-2.0229781299813, lpmf);
Assert.AreEqual(0.19780423301883465, hf);
Assert.AreEqual(0.60511899351154874, ccdf);
Assert.AreEqual(2, icdf1);
Assert.AreEqual(4, icdf2);
Assert.AreEqual(7, icdf3);
Assert.AreEqual("Poisson(x; λ = 4.2)", str);
}
// Закон Пуассона
// Использование метода скользящего суммирования
public double[] MethodMovingSumm()
{
double[] res = new double[2];
var dist1 = new PoissonDistribution(lambda: 1);
var dist2 = new PoissonDistribution(lambda: 2);
var dist3 = new PoissonDistribution(lambda: 3);
var dist4 = new PoissonDistribution(lambda: 4);
return(res);
}
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 TestDistributionPoisson()
{
const double EPSILON = 0.000001;
IDoubleDistribution dist = new PoissonDistribution(m_model, "PoissonDistribution", Guid.NewGuid(), 5.0);
Assert.AreEqual(5.0, dist.GetValueWithCumulativeProbability(0.50), EPSILON);
dist.SetCDFInterval(0.5, 0.5);
Assert.AreEqual(5.0, dist.GetNext(), EPSILON);
dist.SetCDFInterval(0.0, 1.0);
System.IO.StreamWriter tw = new System.IO.StreamWriter(Environment.GetEnvironmentVariable("TEMP") + "\\DistributionPoisson.csv");
Debug.WriteLine("Generating raw data.");
const int DATASETSIZE = 1500000;
double[] rawData = new double[DATASETSIZE];
for (int x = 0; x < DATASETSIZE; x++)
{
rawData[x] = dist.GetNext();
//tw.WriteLine(rawData[x]);
}
Debug.WriteLine("Performing histogram analysis.");
Histogram1D_Double hist = new Histogram1D_Double(rawData, 0, 25, 25, "distribution");
hist.LabelProvider = new LabelProvider(((Histogram1D_Double)hist).DefaultLabelProvider);
hist.Recalculate();
List <double> expected = new List <double>()// From Excel.
{
10107, 50535, 126337, 210561, 263201, 263201, 219334, 156667, 97917, 54398, 27199, 12363, 5151, 1981,
708, 236, 74, 22, 6, 2, 0, 0, 0, 0, 0
};
IEnumerable <double> ied = new List <int>((int[])hist.Bins).Select(n => (double)n);
List <double> actual = new List <double>((IEnumerable <double>)ied);
double rmsError = Mathematics.RMSErrorCalculator.Calculate(expected, actual);
Assert.IsTrue(rmsError < 75, "Poisson distribution at lambda = 5 does not follow the expected curve.");
if (m_visuallyVerify)
{
Debug.WriteLine("Writing data dump file.");
int[] bins = (int[])hist.Bins;
for (int i = 0; i < bins.Length; i++)
{
//Debug.WriteLine(hist.GetLabel(new int[]{i}) + ", " + bins[i]);
tw.WriteLine(hist.GetLabel(new int[] { i }) + ", " + bins[i] + ", " + expected[i]);
}
tw.Flush();
tw.Close();
System.Diagnostics.Process.Start("excel.exe",
Environment.GetEnvironmentVariable("TEMP") + "\\DistributionPoisson.csv");
}
}
/// <summary>
/// Debug: cover the pla
/// </summary>
/// <param name="img"></param>
/// <param name="tileSize"></param>
/// <param name="coverage"></param>
public void ToNoiseTiles(Image img, Size tileSize, float coverage)
{
List <Bitmap> tileImgs = new List <Bitmap>();
foreach (WangTile wt in tiles)
{
Bitmap bmp = new Bitmap(tileSize.Width, tileSize.Height);
PoissonDistribution.ToImage(wt.distribution, Color.Black, bmp, coverage);
tileImgs.Add(bmp);
}
ToImage(img, tileSize, tileImgs);
}
public void FitTest()
{
PoissonDistribution target = new PoissonDistribution(1);
double[] observations = { 0.2, 0.7, 1.0, 0.33 };
target.Fit(observations);
double expected = 0.5575;
Assert.AreEqual(expected, target.Mean);
}
public static void Main()
{
double[][] input =
GeneralizedLinearModelTests.GravityCourseData
.Select(
x => new double[]
{
Math.Log(x.Distance),
x.CommonBorder,
x.CommonLanguage,
x.ColonialRelationship
})
.ToArray();
double[] response =
GeneralizedLinearModelTests.GravityCourseData
.Select(x => x.Trade)
.ToArray();
double[] weights =
Enumerable.Repeat(1.0, response.Length)
.ToArray();
GeneralizedLinearModel <double> generalized =
GeneralizedLinearModel.PoissonRegression(input, response, weights);
const int count = 10;
IDistribution <double> distribution = new PoissonDistribution(new LogLinkFunction());
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < count; i++)
{
generalized = new GeneralizedLinearModel <double>(input, response, weights, distribution, true);
}
sw.Stop();
System.Console.WriteLine(generalized);
System.Console.WriteLine((double)sw.ElapsedMilliseconds / count);
ParallelOptions options = new ParallelOptions();
sw.Restart();
for (int i = 0; i < count; i++)
{
generalized = new GeneralizedLinearModel <double>(input, response, weights, distribution, true, options);
}
sw.Stop();
System.Console.WriteLine(generalized);
System.Console.WriteLine((double)sw.ElapsedMilliseconds / count);
}
public FuncionPoisson(double[] eventos) : base(eventos)
{
try
{
DistribucionDiscreta = new PoissonDistribution();
DistribucionDiscreta.Fit(eventos);
lambda = ((PoissonDistribution)DistribucionDiscreta).Lambda.ToString("0.0000");
Resultado = new ResultadoAjuste(StringFDP, StringInversa, DistribucionDiscreta.StandardDeviation, DistribucionDiscreta.Mean, DistribucionDiscreta.Variance, this);
}
catch (Exception)
{
Resultado = null;
}
}
public static object TestPoisson(double lambda, double[] x, double[] y)
{
PoissonDistribution dist = new PoissonDistribution(lambda);
dist.Fit(y);
double[] ret = new double[4];
ret[0] = dist.Entropy;
ret[1] = dist.Mean;
ret[2] = dist.Variance;
ret[3] = dist.StandardDeviation;
return(ret);
}
public void BellNumberAsPoissonMoment()
{
// The Bell numbers are the moments of the Poisson distribution
// with \mu = 1.
UnivariateDistribution d = new PoissonDistribution(1.0);
foreach (int r in TestUtilities.GenerateIntegerValues(1, 50, 4))
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(
AdvancedIntegerMath.BellNumber(r),
d.RawMoment(r)
));
}
}
public void TestPoissonDistribution()
{
double[][] para =
{
new double[] { 11, 0, 9, 0.3405106424656610472811084, 0.1085255092982049925567724 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new DiscDistTester(para[i], delegate(double a, double b)
{
var ret = new PoissonDistribution(a);
return(ret);
}
);
tester.Test(1E-14);
}
}
private void SetDistributionFunctionFromString()
{
if (DistributionfunctionString.StartsWith("N"))
{
DistributionFunction = new NormalDistribution(Mean, StDeviation);
}
else if (DistributionfunctionString.StartsWith("Poisson"))
{
DistributionfunctionString = EnsureOnlyOneComma(DistributionfunctionString, 1);
var lambda = double.Parse((DistributionfunctionString.Split('=')[1]).Replace(")", "").Trim(), CultureInfo.InvariantCulture);
DistributionFunction = new PoissonDistribution(lambda);
}
else if (DistributionfunctionString.StartsWith("U"))
{
DistributionfunctionString = EnsureOnlyOneComma(DistributionfunctionString, 2);
var a = double.Parse((DistributionfunctionString.Split('=')[1]).Split(',')[0].Trim(), CultureInfo.InvariantCulture);
var b = double.Parse((DistributionfunctionString.Split('=')[2]).Split(')')[0].Trim(), CultureInfo.InvariantCulture);
DistributionFunction = new UniformContinuousDistribution(a, b);
}
else if (DistributionfunctionString.Contains("x; k ="))
{
DistributionfunctionString = EnsureOnlyOneComma(DistributionfunctionString, 2);
var k = double.Parse((DistributionfunctionString.Split('=')[1]).Split(',')[0].Trim(), CultureInfo.InvariantCulture);
var teta = double.Parse((DistributionfunctionString.Split('=')[2]).Split(')')[0].Trim(), CultureInfo.InvariantCulture);
DistributionFunction = new GammaDistribution(teta, k);
}
else if (DistributionfunctionString.Contains("Gumbel"))
{
DistributionfunctionString = EnsureOnlyOneComma(DistributionfunctionString, 2);
var u = double.Parse((DistributionfunctionString.Split('=')[1]).Split(',')[0].Trim(), CultureInfo.InvariantCulture);
var b = double.Parse((DistributionfunctionString.Split('=')[2]).Split(')')[0].Trim(), CultureInfo.InvariantCulture);
DistributionFunction = new GumbelDistribution(u, b);
}
else
{
throw new Exception("Unregnoized disitrubtionfunction " + DistributionfunctionString);
}
}
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));
}
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());
}
static void Main(string[] args)
{
var poisson = new PoissonDistribution(9);
//Console.WriteLine("CDF 1 : " + poisson.Cdf(1) + ", CDF0: " + poisson.Cdf0(1));
//Console.WriteLine("CDF 5 : " + poisson.Cdf(5) + ", CDF0: " + poisson.Cdf0(5));
//Console.WriteLine("CDF 7 : " + poisson.Cdf(7) + ", CDF0: " + poisson.Cdf0(7));
//Console.WriteLine("CDF 9 : " + poisson.Cdf(9) + ", CDF0: " + poisson.Cdf0(9));
//Console.WriteLine("CDF 10 : " + poisson.Cdf(10) + ", CDF0: " + poisson.Cdf0(10));
//Console.WriteLine("CDF 12 : " + poisson.Cdf(12) + ", CDF0: " + poisson.Cdf0(12));
//Console.WriteLine("CDF 14 : " + poisson.Cdf(14) + ", CDF0: " + poisson.Cdf0(14));
//Console.WriteLine("CDF 15 : " + poisson.Cdf(15) + ", CDF0 :" + poisson.Cdf0(15));
//Console.WriteLine("CDF 27 : " + poisson.Cdf(27) + ", CDF0 :" + poisson.Cdf0(27));
//Console.WriteLine("CDF 20 : " + poisson.Cdf(20) + ", CDF0 :" + poisson.Cdf0(20));
//Console.WriteLine("----PoissonDistribution(1800)---");
//poisson = new PoissonDistribution(1800);
//Console.WriteLine("CDF 100 : " + poisson.Cdf(100) + ", CDF1: " + poisson.Cdf1(100));
//Console.WriteLine("CDF 500 : " + poisson.Cdf(500) + ", CDF1: " + poisson.Cdf1(500));
//Console.WriteLine("CDF 700 : " + poisson.Cdf(700) + ", CDF1: " + poisson.Cdf1(700));
//Console.WriteLine("CDF 900 : " + poisson.Cdf(900) + ", CDF1: " + poisson.Cdf1(900));
//Console.WriteLine("CDF 1000 : " + poisson.Cdf(1000) + ", CDF1: " + poisson.Cdf1(1000));
//Console.WriteLine("CDF 1200 : " + poisson.Cdf(1200) + ", CDF1: " + poisson.Cdf1(1200));
//Console.WriteLine("CDF 1400 : " + poisson.Cdf(1400) + ", CDF1: " + poisson.Cdf1(1400));
//Console.WriteLine("CDF 1500 : " + poisson.Cdf(1500) + ", CDF1 :" + poisson.Cdf1(1500));
//Console.WriteLine("CDF 1700 : " + poisson.Cdf(1700) + ", CDF1 :" + poisson.Cdf1(1700));
//Console.WriteLine("CDF 1900 : " + poisson.Cdf(1900) + ", CDF1 :" + poisson.Cdf1(1900));
//Console.WriteLine("CDF 2100 : " + poisson.Cdf(2100) + ", CDF1 :" + poisson.Cdf1(2100));
//Console.WriteLine("CDF 2300 : " + poisson.Cdf(2300) + ", CDF1 :" + poisson.Cdf1(2300));
//Console.WriteLine("CDF 2500 : " + poisson.Cdf(2500) + ", CDF1 :" + poisson.Cdf1(2500));
Console.WriteLine("CDF 2700 : " + poisson.Cdf(2700) + ", CDF1 :" + poisson.Cdf1(2700));
for (int i = 3; i < 300; i++)
{
var d = poisson.Factorial(i) - poisson.Factorial1(i);
Console.WriteLine("i: " + i + ", Factorial: " + poisson.Factorial(i) + ", Factorial1: " + poisson.Factorial1(i) + ", diff: " + d);
}
//for (int i = 3; i < 160; i++)
//{
// Console.WriteLine("i: " + i + ", PMF: " + poisson.Pmf(i));
//}
Console.ReadKey();
}
private void Display()
{
Cursor = Cursors.WaitCursor;
var distribution = new PoissonDistribution().GetNormalizedValues(_threadCount);
// Get the time delta between each sample point.
var delta = TimeSpan.FromTicks(_duration.Ticks / (distribution.Count() - 1));
_barSeries.DataPoints.Clear();
for (int i = 0; i < distribution.Count(); i++)
{
var time = TimeSpan.FromSeconds(delta.TotalSeconds * i);
var dataPoint = new CategoricalDataPoint(distribution.ElementAt(i), time.ToString(@"hh\:mm\:ss"));
_barSeries.DataPoints.Add(dataPoint);
}
Cursor = Cursors.Default;
}
public Order(Distributions ad, Distributions td)
{
ammountDistribution = ad;
timeDistribution = td;
Ammount = NonNegativeValue(new Func <double>(() =>
{
switch (ammountDistribution)
{
case Distributions.Normal: return(NormalDistribution.OrderSize());
case Distributions.Poisson: return(PoissonDistribution.OrderSize());
case Distributions.Exponential: return(ExponentialDistribution.OrderSize());
case Distributions.UniformCont: return(UniformContDistribution.OrderSize());
case Distributions.UniformDisc: return(UniformDiscDistribution.OrderSize());
default: return(-1);
}
})());
Time = NonNegativeValue(new Func <double>(() =>
{
switch (timeDistribution)
{
case Distributions.Normal: return(NormalDistribution.TimeBetweenOrder());
case Distributions.Poisson: return(PoissonDistribution.TimeBetweenOrder());
case Distributions.Exponential: return(ExponentialDistribution.TimeBetweenOrder());
case Distributions.UniformCont: return(UniformContDistribution.TimeBetweenOrder());
case Distributions.UniformDisc: return(UniformDiscDistribution.TimeBetweenOrder());
default: return(-1);
}
})());
}
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++;
}
}
//---------------------------------------------------------------------
///<summary>
/// Run the plug-in at a particular timestep.
///</summary>
public override void Run()
{
if (isDebugEnabled)
UI.WriteLine("Running {0} at time = {1}", Name, Model.Core.CurrentTime);
UI.WriteLine(" Processing landscape for Fire events ...");
SiteVars.Event.SiteValues = null;
SiteVars.Severity.ActiveSiteValues = 0;
SiteVars.Disturbed.ActiveSiteValues = false;
SiteVars.TravelTime.ActiveSiteValues = Double.PositiveInfinity;
SiteVars.MinNeighborTravelTime.ActiveSiteValues = Double.PositiveInfinity;
SiteVars.RateOfSpread.ActiveSiteValues = 0.0;
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
summaryFireRegionEventCount[fire_region.Index] = 0;
summaryFireRegionSeverity[fire_region.Index] = 0;
}
summaryTotalSites = 0;
summaryEventCount = 0;
// Update the FireRegions Map as necessary:
//UI.WriteLine(" Dynamic Fire: Loading Dynamic Fire Regions...");
foreach(IDynamicFireRegion dyneco in dynamicEcos)
{
if(dyneco.Year == Model.Core.CurrentTime)
{
UI.WriteLine(" Reading in new Fire FireRegions Map {0}.", dyneco.MapName);
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
fire_region.FireRegionSites = new List<Location>();
}
FireRegions.ReadMap(dyneco.MapName); //Sites added to their respective fire_region lists
}
}
//Update the weather table as necessary:
//UI.WriteLine(" Dynamic Fire: Loading Dynamic Weather ...");
foreach (IDynamicWeather dynweather in dynamicWeather)
{
if (dynweather.Year == Model.Core.CurrentTime)
{
UI.WriteLine(" Reading in new Weather Table {0}", dynweather.FileName);
WeatherDataTable = Weather.ReadWeatherFile(dynweather.FileName, FireRegions.Dataset, seasonParameters);
//Weather.ReadFileName(, seasonParameters, FireRegions.Dataset);
}
}
// Fill in open types as needed:
if (isDebugEnabled)
UI.WriteLine("Filling open types as needed ...");
UI.WriteLine(" Dynamic Fire: Filling open types as needed ...");
foreach (ActiveSite site in Model.Core.Landscape)
{
IFireRegion fire_region = SiteVars.FireRegion[site];
if(fire_region == null)
throw new System.ApplicationException("Error: SiteVars.FireRegion is empty.");
//if(SiteVars.CFSFuelType[site] == 0)
// throw new System.ApplicationException("Error: SiteVars.CFSFuelType is empty.");
if(Event.FuelTypeParms[SiteVars.CFSFuelType[site]] == null)
{
UI.WriteLine("Error: SiteVars.CFSFuelType[site]={0}.", SiteVars.CFSFuelType[site]);
throw new System.ApplicationException("Error: Event BaseFuel Empty.");
}
if(Event.FuelTypeParms[SiteVars.CFSFuelType[site]].BaseFuel == BaseFuelType.NoFuel)
{
if(SiteVars.PercentDeadFir[site] == 0)
SiteVars.CFSFuelType[site] = fire_region.OpenFuelType;
}
}
if (isDebugEnabled)
UI.WriteLine("Done filling open types");
UI.WriteLine(" Dynamic Fire: Igniting Fires ...");
foreach (IFireRegion fire_region in FireRegions.Dataset)
{
if (fire_region.EcoIgnitionNum > 0)
{
PoissonDistribution randVar = new PoissonDistribution(RandomNumberGenerator.Singleton);
double doubleLambda;
int ignGenerated = 0;
if (isDebugEnabled)
UI.WriteLine("{0}: EcoIgnitionNum = {1}, computing ignGenerated ...",
fire_region.Name, fire_region.EcoIgnitionNum);
if (fire_region.EcoIgnitionNum < 1)
{
// Adjust ignition probability for multiple years
// (The inverse of the probability of NOT having any ignition for the time period.)
// P = 1 - (1-Pignition)^timestep
//doubleLambda = 1 - System.Math.Pow(1.0 - fire_region.EcoIgnitionNum, Timestep);
for (int i = 1; i <= Timestep; i++)
{
int annualFires = 0;
if (Util.Random.GenerateUniform() <= fire_region.EcoIgnitionNum)
{
annualFires = 1;
}
ignGenerated += annualFires;
}
}
else
{
doubleLambda = fire_region.EcoIgnitionNum;
bool boolLarge = false;
// 745 is the upper limit for valid Poisson lambdas. If greater than
// 745, divide by 10 and readjust back up below.
if (doubleLambda > 745)
{
doubleLambda = doubleLambda / 10;
boolLarge = true;
}
//bool boolLambda = randVar.IsValidLambda(doubleLambda);
randVar.Lambda = doubleLambda;
for (int i = 1; i <= Timestep; i++)
{
int annualFires = randVar.Next();
if (boolLarge)
annualFires = annualFires * 10; //readjust if necessary.
ignGenerated += annualFires;
}
}
if (isDebugEnabled)
UI.WriteLine(" ignGenerated = {0}; Shuffling {0} cells ...",
ignGenerated, fire_region.FireRegionSites.Count);
List<Location> cellsPerFireRegion = fire_region.FireRegionSites;
Landis.Util.Random.Shuffle(cellsPerFireRegion);
int fireCount = 0;
//Try to create poissonNumber of fires in each fire_region.
//Fires should only initiate if a fire event has not previously occurred
//at that site.
if (isDebugEnabled)
{
UI.WriteLine(" Trying to create fires... ");
UI.WriteLine(" there are {0} site locations in fire region {1}", cellsPerFireRegion.Count, fire_region.Name);
}
foreach (Location siteLocation in cellsPerFireRegion)
{
Site site = Model.Core.Landscape.GetSite(siteLocation);
ActiveSite asite = site as ActiveSite;
if (fireCount >= ignGenerated) continue; //exit loop if the required number of fires has occurred.
if (SiteVars.Event[asite] == null)
{
fireCount++;
if (isDebugEnabled)
UI.WriteLine(" fireCount = {0}", fireCount);
Event FireEvent = Event.Initiate(asite, Timestep, fireSizeType, bui, seasonParameters, severityCalibrate);
if (isDebugEnabled)
UI.WriteLine(" fire event {0}started at {1}",
FireEvent == null ? "not ": "",
asite.Location);
if (FireEvent != null)
{
LogEvent(Model.Core.CurrentTime, FireEvent);
summaryEventCount++;
//fireCount++; //RMS test
}
}
}
}
}
// Track the time of last fire; registered in SiteVars.cs for other extensions to access.
if (isDebugEnabled)
UI.WriteLine("Assigning TimeOfLastFire site var ...");
foreach (Site site in Model.Core.Landscape.AllSites)
if(SiteVars.Disturbed[site])
SiteVars.TimeOfLastFire[site] = Model.Core.CurrentTime;
// Write Fire severity map
UI.WriteLine(" Dynamic Fire: Write Severity Map ...");
string path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<SeverityPixel> map = CreateMap(path);
using (map) {
SeverityPixel pixel = new SeverityPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive) {
if (SiteVars.Disturbed[site])
{
pixel.Band0 = (byte)(SiteVars.Severity[site] + 2);
summaryFireRegionSeverity[SiteVars.FireRegion[site].Index] += SiteVars.Severity[site];
}
else
pixel.Band0 = 1;
}
else {
// Inactive site
pixel.Band0 = 0;
}
map.WritePixel(pixel);
}
}
/*
// Write travel time map
path = MapNames.ReplaceTemplateVars("./DFFS-output/travel-time-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> umap = CreateTravelTimeMap(path);
using (umap) {
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive) {
if (!Double.IsPositiveInfinity(SiteVars.TravelTime[site]))
//if (SiteVars.Event[site] != null)
pixel.Band0 = (ushort) ((SiteVars.TravelTime[site]) + 2);
else
pixel.Band0 = 1;
}
else {
// Inactive site
pixel.Band0 = 0;
}
umap.WritePixel(pixel);
}
}
*/
/*
// Write topo map
path = MapNames.ReplaceTemplateVars("./DFFS-output/topo-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<TopoPixel> tmap = CreateTopoMap(path);
using (tmap)
{
TopoPixel pixel = new TopoPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.GroundSlope[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
tmap.WritePixel(pixel);
}
}
*/
/*
// Write wind speed map
path = MapNames.ReplaceTemplateVars("./DFFS-output/WSV-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> wsvmap = CreateTravelTimeMap(path);
using (wsvmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.SiteWindSpeed[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
wsvmap.WritePixel(pixel);
}
}
*/
/*
// Write wind direction map
path = MapNames.ReplaceTemplateVars("./DFFS-output/WindDir-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> winddirmap = CreateTravelTimeMap(path);
using (winddirmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.SiteWindDirection[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
winddirmap.WritePixel(pixel);
}
}
*/
/*
// Write ROS map
/*path = MapNames.ReplaceTemplateVars("./DFFS-output/ROS-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> rosmap = CreateTravelTimeMap(path);
using (rosmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)((SiteVars.RateOfSpread[site]) + 1);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
rosmap.WritePixel(pixel);
}
}*/
/*
// Write AdjROS map
path = MapNames.ReplaceTemplateVars("./DFFS-output/AdjROS-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> adjmap = CreateTravelTimeMap(path);
using (adjmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(((SiteVars.AdjROS[site]) * 100) + 1);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
adjmap.WritePixel(pixel);
}
}
*/
// Write TimeOfLastFire map
path = MapNames.ReplaceTemplateVars("./DFFS-output/TimeOfLastFire-{timestep}.gis", Model.Core.CurrentTime);
IOutputRaster<UShortPixel> tolfMap = CreateTravelTimeMap(path);
using (tolfMap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.TimeOfLastFire[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
tolfMap.WritePixel(pixel);
}
}
WriteSummaryLog(Model.Core.CurrentTime);
if (isDebugEnabled)
UI.WriteLine("Done running extension");
}
/// <summary>
/// Returns a new line chart plotting the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <returns>A new chart.</returns>
public static ChartControl ToChart( PoissonDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
ChartControl chart = GetDefaultChart();
Update( ref chart, dist, function );
return chart;
}
/// <summary>
/// Updates the given chart with the specified distribution.
/// </summary>
/// <param name="chart">A chart.</param>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <returns>A new chart.</returns>
/// <remarks>
/// Plots the specified function of the given distribution for 0.0001 <= p <= 0.9999.
/// <br/>
/// Titles are added only if chart does not currently contain any titles.
/// <br/>
/// chart.Series[0] is replaced, or added if necessary.
/// </remarks>
public static void Update( ref ChartControl chart, PoissonDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
List<string> titles = new List<string>()
{
"PoissonDistribution",
String.Format("\u03BB={0}", dist.Mean)
};
UpdateDiscreteDistribution( ref chart, dist, titles, function );
}
//---------------------------------------------------------------------
///<summary>
/// Run the plug-in at a particular timestep.
///</summary>
public override void Run()
{
UI.WriteLine("Processing landscape for Fire events ...");
SiteVars.Event.SiteValues = null;
SiteVars.Severity.ActiveSiteValues = 0;
SiteVars.Disturbed.ActiveSiteValues = false;
SiteVars.TravelTime.ActiveSiteValues = Double.PositiveInfinity;
SiteVars.MinNeighborTravelTime.ActiveSiteValues = Double.PositiveInfinity;
SiteVars.RateOfSpread.ActiveSiteValues = 0.0;
// Fill in open types as needed:
foreach (ActiveSite site in Model.Core.Landscape)
{
if((FuelTypeCode) SiteVars.CFSFuelType[site] == FuelTypeCode.NoFuel)
{
IEcoregion ecoregion = SiteVars.Ecoregion[site];
IMoreEcoregionParameters fireParms = ecoregion.MoreEcoregionParameters;
SiteVars.CFSFuelType[site] = (int) fireParms.OpenFuelType;
}
}
foreach (IEcoregion ecoregion in Ecoregions.Dataset)
{
summaryEcoregionEventCount[ecoregion.Index] = 0;
}
summaryTotalSites = 0;
summaryEventCount = 0;
//-----Edited by BRM to incorporate Poisson selection of ignition #-----
/*
//-----This section is original method
foreach (ActiveSite site in Model.Core.Landscape)
{
IEcoregion ecoregion = SiteVars.Ecoregion[site];
IMoreEcoregionParameters fireParms = ecoregion.MoreEcoregionParameters;
if(Util.Random.GenerateUniform() <= fireParms.EcoIgnitionProb)
{
Event FireEvent = Event.Initiate(site, Timestep, fireSizeType, bui, seasonParameters, windDirectionParameters);
if (FireEvent != null)
{
LogEvent(Model.Core.CurrentTime, FireEvent);
summaryEventCount++;
}
}
}
//----------
*/
//-----This section replaces removed section above-----
foreach (IEcoregion ecoregion in Ecoregions.Dataset)
{
IMoreEcoregionParameters fireParms = ecoregion.MoreEcoregionParameters;
if (fireParms.EcoIgnitionProb > 0)
{
PoissonDistribution randVar = new PoissonDistribution(RandomNumberGenerator.Singleton);
double doubleLambda;
int ignGenerated = 0;
if (fireParms.EcoIgnitionProb < 1)
{
doubleLambda = fireParms.EcoIgnitionProb * Timestep;
if (doubleLambda < 1)
{
if (Util.Random.GenerateUniform() <= doubleLambda)
{
randVar.Lambda = 1;
ignGenerated = randVar.Next();
}
else
{
ignGenerated = 0;
}
}
else
{
randVar.Lambda = doubleLambda;
ignGenerated = randVar.Next();
}
}
else
{
doubleLambda = fireParms.EcoIgnitionProb;
bool boolLarge = false;
if (doubleLambda > 745)
{
doubleLambda = doubleLambda / 10;
boolLarge = true;
}
bool boolLambda = randVar.IsValidLambda(doubleLambda);
randVar.Lambda = doubleLambda;
for (int i = 1; i <= Timestep; i++)
{
int annualFires = randVar.Next();
if (boolLarge)
annualFires = annualFires * 10;
ignGenerated += annualFires;
}
}
List<Location> cellsPerEcoregion = ecoregion.MoreEcoregionParameters.EcoregionSites;
Landis.Util.Random.Shuffle(cellsPerEcoregion);
int fireCount = 0;
//Try to create poissonNumber of fires in each ecoregion.
//Fires should only initiate if a fire event has not previously occurred
//at that site.
foreach (Location siteLocation in cellsPerEcoregion)
{
Site site = Model.Core.Landscape.GetSite(siteLocation);
ActiveSite asite = site as ActiveSite;
if (fireCount >= ignGenerated) continue; //exit loop if the required number of fires has occurred.
if (SiteVars.Event[asite] == null)
{
fireCount++;
Event FireEvent = Event.Initiate(asite, Timestep, fireSizeType, bui, seasonParameters, windDirectionParameters);
if (FireEvent != null)
{
LogEvent(Model.Core.CurrentTime, FireEvent);
summaryEventCount++;
}
}
}
}
}
//----------
//UI.WriteLine(" Fire events: {0}", summaryEventCount);
// Write Fire severity map
string path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<SeverityPixel> map = CreateMap(path);
using (map) {
SeverityPixel pixel = new SeverityPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive) {
if (SiteVars.Disturbed[site])
pixel.Band0 = (byte) (SiteVars.Severity[site] + 2);
else
pixel.Band0 = 1;
}
else {
// Inactive site
pixel.Band0 = 0;
}
map.WritePixel(pixel);
}
}
// Write travel time map
path = MapNames.ReplaceTemplateVars("./tests/Fire-2006/travel-time-{timestep}.gis", Model.Core.CurrentTime);
//path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<UShortPixel> umap = CreateTravelTimeMap(path);
using (umap) {
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites) {
if (site.IsActive) {
if (!Double.IsPositiveInfinity(SiteVars.TravelTime[site]))
//if (SiteVars.Event[site] != null)
pixel.Band0 = (ushort) ((SiteVars.TravelTime[site]) + 2);
else
pixel.Band0 = 1;
}
else {
// Inactive site
pixel.Band0 = 0;
}
umap.WritePixel(pixel);
}
}
// Write topo map
path = MapNames.ReplaceTemplateVars("./tests/Fire-2006/topo-{timestep}.gis", Model.Core.CurrentTime);
//path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<TopoPixel> tmap = CreateTopoMap(path);
using (tmap)
{
TopoPixel pixel = new TopoPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.GroundSlope[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
tmap.WritePixel(pixel);
}
}
// Write wind speed map
path = MapNames.ReplaceTemplateVars("./tests/Fire-2006/WSV-{timestep}.gis", Model.Core.CurrentTime);
//path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<UShortPixel> wsvmap = CreateTravelTimeMap(path);
using (wsvmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.SiteWindSpeed[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
wsvmap.WritePixel(pixel);
}
}
// Write ROS map
path = MapNames.ReplaceTemplateVars("./tests/Fire-2006/ROS-{timestep}.gis", Model.Core.CurrentTime);
//path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<UShortPixel> rosmap = CreateTravelTimeMap(path);
using (rosmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)(SiteVars.RateOfSpread[site]);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
rosmap.WritePixel(pixel);
}
}
// Write AdjROS map
path = MapNames.ReplaceTemplateVars("./tests/Fire-2006/AdjROS-{timestep}.gis", Model.Core.CurrentTime);
//path = MapNames.ReplaceTemplateVars(mapNameTemplate, Model.Core.CurrentTime);
IOutputRaster<UShortPixel> adjmap = CreateTravelTimeMap(path);
using (adjmap)
{
UShortPixel pixel = new UShortPixel();
foreach (Site site in Model.Core.Landscape.AllSites)
{
if (site.IsActive)
{
pixel.Band0 = (ushort)((SiteVars.AdjROS[site]) * 100);
}
else
{
// Inactive site
pixel.Band0 = 0;
}
adjmap.WritePixel(pixel);
}
}
WriteSummaryLog(Model.Core.CurrentTime);
}
/// <summary>
/// Shows a new chart in a default form.
/// </summary>
/// <param name="dist">The distribution.</param>
/// <param name="function">The distribution function to plot.</param>
/// <remarks>
/// Equivalent to:
/// <code>
/// NMathStatsChart.Show( ToChart( dist, function ) );
/// </code>
/// </remarks>
public static void Show( PoissonDistribution dist, DistributionFunction function = DistributionFunction.PDF )
{
Show( ToChart( dist, function ) );
}
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 GenerateVehicle()
{
int generateVehicles;
Random Random = new Random();
int RandomNum;
PoissonDistribution P = new PoissonDistribution(0);
foreach (Road road in Simulator.RoadManager.GetGenerateVehicleRoadList())
{
if (road.generateLevel_lambda > 0 && DrivingPathList[road.roadID].Count >= 1)
{
generateVehicles = 0;
double lambda = road.generateLevel_lambda / (60 / vehicleGenerateInterval) ;
P.SetLambda(lambda);
RandomNum = Random.Next(999);
if (!vehicleWeight)
{
if (RandomNum >= P.CummulitiveDistributionFunction(0) * 1000)
{
generateVehicles = 1;
}
}
else if (vehicleWeight)
{
while (RandomNum >= P.CummulitiveDistributionFunction(generateVehicles) * 1000)
{
generateVehicles++;
}
}
if (generateVehicles > 0)
{
if (Simulator.TESTMODE)
Simulator.UI.AddMessage("System", "Road : " + road.roadID + " Generate " + generateVehicles + " Vehicles");
CreateVehicle(road, generateVehicles);
}
}
}
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PoissonDistribution obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
