public void BernoulliDistribution_MaximumLikelihood_FromClassifiedSample()
{
// arrange
var distr = new BernoulliDistribution();
var sample = new ClassifiedSample <double[]>
{
{ new[] { 1.0D, 1.0D, 0.0D }, new Class("A", 0) },
{ new[] { 1.0D, 0.0D, 1.0D }, new Class("A", 0) },
{ new[] { 0.0D, 0.0D, 1.0D }, new Class("B", 1) },
{ new[] { 0.0D, 0.0D, 0.0D }, new Class("B", 1) },
};
// act
var res = distr.FromSample(sample);
var dA1 = res[0][0];
var dA2 = res[0][1];
var dA3 = res[0][2];
var dB1 = res[1][0];
var dB2 = res[1][1];
var dB3 = res[1][2];
// assert
Assert.AreEqual(1.0D, dA1.P, EPS);
Assert.AreEqual(0.5D, dA2.P, EPS);
Assert.AreEqual(0.5D, dA3.P, EPS);
Assert.AreEqual(0.0D, dB1.P, EPS);
Assert.AreEqual(0.0D, dB2.P, EPS);
Assert.AreEqual(0.5D, dB3.P, EPS);
}
protected override void EndProcessing()
{
var dist = new BernoulliDistribution(Mean);
var obj = DistributionHelper.AddConvinienceMethods(dist);
WriteObject(obj);
}
public void icdf()
{
// install.packages('LaplacesDemon')
// library('LaplacesDemon')
//
BernoulliDistribution dist = new BernoulliDistribution(0.5);
double[] percentiles = Vector.Range(0.0, 1.0, stepSize: 0.1);
for (int i = 0; i < percentiles.Length; i++)
{
double x = percentiles[i];
int icdf = dist.InverseDistributionFunction(x);
double cdf = dist.DistributionFunction(icdf);
int iicdf = dist.InverseDistributionFunction(cdf);
double iiicdf = dist.DistributionFunction(iicdf);
if (i < 6) // qbern(p=((0:10)/10), prob=0.5)
{
Assert.AreEqual(0, icdf);
}
else
{
Assert.AreEqual(1, icdf);
}
double rx = System.Math.Round(x, MidpointRounding.ToEven);
double rc = System.Math.Round(cdf, MidpointRounding.ToEven);
Assert.AreEqual(rx, rc, 1e-5);
Assert.AreEqual(iicdf, icdf, 1e-5);
Assert.AreEqual(iiicdf, cdf, 1e-5);
}
}
public void ComplementaryDistributionFunctionTest()
{
BernoulliDistribution target = new BernoulliDistribution(0.42);
{
double expected = 1.0 - target.DistributionFunction(0);
double actual = target.ComplementaryDistributionFunction(0);
Assert.AreEqual(expected, actual, 1e-6);
}
{
double expected = 1.0 - target.DistributionFunction(1);
double actual = target.ComplementaryDistributionFunction(1);
Assert.AreEqual(expected, actual, 1e-6);
}
{
double expected = 1.0 - target.DistributionFunction(-1);
double actual = target.ComplementaryDistributionFunction(-1);
Assert.AreEqual(expected, actual, 1e-6);
}
{
double expected = 1.0 - target.DistributionFunction(2);
double actual = target.ComplementaryDistributionFunction(2);
Assert.AreEqual(expected, actual, 1e-6);
}
}
public void BernoulliDistributionFit()
{
double p = 0.25;
int n0 = 0;
int n1 = 0;
Random rng = new Random(3);
for (int i = 0; i < 100; i++)
{
if (rng.NextDouble() < p)
{
n1++;
}
else
{
n0++;
}
}
BernoulliFitResult fit = BernoulliDistribution.FitToSample(n0, n1);
Assert.IsTrue(fit.P.ConfidenceInterval(0.95).ClosedContains(p));
Assert.IsTrue(fit.GoodnessOfFit.Probability > 0.05);
Assert.IsTrue(fit.Parameters.Count == 1);
Assert.IsTrue(fit.Parameters[0].Estimate == fit.P);
}
IEnumerator run()
{
List <Vector2Int> points = new List <Vector2Int> {
new Vector2Int(m_path.min.x, m_path.max.y), m_path.min, new Vector2Int(m_path.max.x, m_path.min.y), m_path.max
};
bool direction = new BernoulliDistribution().Next(new StaticRandomGenerator <DefaultRandomGenerator>());
if (direction)
{
var temp = points[0];
points[0] = points[3];
points[3] = temp;
temp = points[2];
points[2] = points[1];
points[1] = temp;
}
int currentIndex = 0;
while (true)
{
var d = (new Vector2(transform.position.x, transform.position.y) - points[currentIndex]).magnitude;
transform.DOMove(new Vector3(points[currentIndex].x, points[currentIndex].y, transform.position.z), d / m_speed).SetEase(Ease.Linear);
currentIndex = (currentIndex + 1) % points.Count;
yield return(new WaitForSeconds(d / m_speed));
}
}
public void BernoulliDistribution()
{
Simulation.NumberOfSamples = 5;
JsonSerializer serializer = JsonSerializer.Create(JsonSettings.SerializerSettings);
string name = "My Distribution";
var val = new BernoulliDistribution(0.75, 0)
{
Name = name
};
Guid guid = val.Guid;
string json = JObject.FromObject(val, serializer).ToString();
Simulation.ClearDistributionList();
var newVal = JObject.Parse(json).ToObject <BernoulliDistribution>(serializer);
Assert.AreEqual(val.Guid, newVal.Guid);
Assert.AreEqual(val.ConstrainedToInt, newVal.ConstrainedToInt);
Assert.AreEqual(val.RandomSeed, newVal.RandomSeed);
Assert.AreEqual(val.Probability.ScalarValue, newVal.Probability.ScalarValue);
Assert.AreEqual(val.Minimum, newVal.Minimum);
Assert.AreEqual(val.Maximum, newVal.Maximum);
Assert.AreEqual(val.Mean, newVal.Mean);
Assert.AreEqual(val.Name, name);
}
public void ConstructorTest()
{
var bern = new BernoulliDistribution(mean: 0.42);
// Common measures
double mean = bern.Mean; // 0.42
double median = bern.Median; // 0.0
double var = bern.Variance; // 0.2436
double mode = bern.Mode; // 0.0
// Probability mass functions
double pdf = bern.ProbabilityMassFunction(k: 1); // 0.42
double lpdf = bern.LogProbabilityMassFunction(k: 0); // -0.54472717544167193
// Cumulative distribution function
double cdf = bern.DistributionFunction(k: 0); // 0.58
double ccdf = bern.ComplementaryDistributionFunction(k: 0); // 0.42
// Quantile function
int icdf0 = bern.InverseDistributionFunction(p: 0.57); // 0
int icdf1 = bern.InverseDistributionFunction(p: 0.59); // 1
double hf = bern.HazardFunction(x: 0); // 1.3809523809523814
double chf = bern.CumulativeHazardFunction(x: 0); // 0.86750056770472328
string str = bern.ToString(CultureInfo.InvariantCulture); // "Bernoulli(x; p = 0.42, q = 0.58)"
Assert.AreEqual(0.42, mean);
Assert.AreEqual(0.0, median);
Assert.AreEqual(0.2436, var);
Assert.AreEqual(0.0, mode);
Assert.AreEqual(0.86750056770472328, chf, 1e-10);
Assert.AreEqual(0.58, cdf, 1e-10);
Assert.AreEqual(0.42, pdf);
Assert.AreEqual(-0.54472717544167193, lpdf);
Assert.AreEqual(1.3809523809523814, hf, 1e-10);
Assert.AreEqual(0.42, ccdf, 1e-10);
Assert.AreEqual(0, icdf0);
Assert.AreEqual(1, icdf1);
Assert.AreEqual("Bernoulli(x; p = 0.42, q = 0.58)", str);
var range1 = bern.GetRange(0.95);
var range2 = bern.GetRange(0.99);
var range3 = bern.GetRange(0.01);
Assert.AreEqual(0, range1.Min);
Assert.AreEqual(1.0, range1.Max);
Assert.AreEqual(0, range2.Min);
Assert.AreEqual(1.0, range2.Max);
Assert.AreEqual(0, range3.Min);
Assert.AreEqual(1.0, range3.Max);
Assert.AreEqual(0, bern.Support.Min);
Assert.AreEqual(1, bern.Support.Max);
Assert.AreEqual(bern.InverseDistributionFunction(0), bern.Support.Min);
Assert.AreEqual(bern.InverseDistributionFunction(1), bern.Support.Max);
}
public static BernoulliDistribution Bernoulli(double p)
{
var result = new BernoulliDistribution();
result.Params = new BernoulliDistribution.Parameters(p);
return(result);
}
public void DistributionFunctionTest()
{
BernoulliDistribution target = new BernoulliDistribution(0.6);
double expected = 0.4;
double actual = target.DistributionFunction(0);
Assert.AreEqual(expected, actual, 1e-6);
}
public void LogProbabilityMassFunctionTest()
{
BernoulliDistribution target = new BernoulliDistribution(0.6);
double expected = System.Math.Log(0.6);
double actual = target.LogProbabilityMassFunction(1);
Assert.AreEqual(expected, actual, 1e-6);
}
public void BalancedTest()
{
var distribution = BernoulliDistribution.Balanced();
Assert.AreEqual(
expected: 0.5,
actual: distribution.SuccessProbability,
delta: DoubleMatrixTest.Accuracy);
}
public void GenerationTest()
{
double prob = 0.5;
int trials = 100000;
BernoulliDistribution target = new BernoulliDistribution(prob);
target.Fit(target.Generate(trials).Select(x => (double)x).ToArray());
Assert.AreEqual(target.Mean, prob, 1e-2);
}
public void BernoulliDistribution()
{
Simulation.NumberOfSamples = ExpectedResults.NumberOfSamples;
var testInfo = ExpectedResults.Data["DistributionResults"]["BernoulliDistribution"];
var inputs = testInfo["ConstructorInputs"];
var resultsArray = testInfo["Results"]
.Select(jv => (double)jv).ToArray();
BernoulliDistribution distr = new BernoulliDistribution(
inputs["probability"].Value <double>(),
inputs["randomSeed"].Value <int>());
Vector <double> expectedResults = Vector <double> .Build.DenseOfArray(resultsArray);
Assert.AreEqual(expectedResults, distr.GetResult());
distr = new BernoulliDistribution(.567);
Assert.AreEqual(distr.Probability.ScalarValue, .567);
bool exceptionCaught = false;
try
{
distr.Probability = -1;
}
catch (ArgumentException)
{
exceptionCaught = true;
}
Assert.IsTrue(exceptionCaught);
exceptionCaught = false;
try
{
distr.Probability = 1.1;
}
catch (ArgumentException)
{
exceptionCaught = true;
}
Assert.IsTrue(exceptionCaught);
distr.Probability = 0;
distr.Probability = 1;
Assert.IsTrue(distr.ConstrainedToInt);
distr = new BernoulliDistribution();
Assert.AreEqual(1, distr.Probability.ScalarValue);
}
public void BernoulliDistribution_MaximumLikelihood_FromSample()
{
// arrange
var distr = new BernoulliDistribution();
var sample = new[] { 1.0D, 1.0D, 0.0D, 1.0D };
// act
distr.FromSample(sample);
var pars = distr.Params;
// assert
Assert.AreEqual(0.75D, pars.P);
}
public void SuccessProbabilityTest()
{
// Valid successProbability
{
var distribution = BernoulliDistribution.Balanced();
var expected = 0.12;
distribution.SuccessProbability = expected;
Assert.AreEqual(
expected: expected,
actual: distribution.SuccessProbability,
delta: DoubleMatrixTest.Accuracy);
}
// successProbability < 0
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
BernoulliDistribution.Balanced().SuccessProbability = -2.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "value");
}
// successProbability > 1
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
BernoulliDistribution.Balanced().SuccessProbability = 2.0;
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "value");
}
}
public void ConstructorTest()
{
// Valid input
{
var successProbability = 0.18;
var distribution = new BernoulliDistribution(
successProbability: successProbability);
Assert.AreEqual(
expected: successProbability,
actual: distribution.SuccessProbability,
delta: DoubleMatrixTest.Accuracy);
}
// successProbability < 0
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
new BernoulliDistribution(successProbability: -2.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "successProbability");
}
// successProbability > 1
{
string STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL =
string.Format(
ImplementationServices.GetResourceString(
"STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL"),
"0", "1");
ArgumentExceptionAssert.Throw(
() =>
{
new BernoulliDistribution(successProbability: 2.0);
},
expectedType: typeof(ArgumentOutOfRangeException),
expectedPartialMessage: STR_EXCEPT_PAR_NOT_IN_CLOSED_INTERVAL,
expectedParameterName: "successProbability");
}
}
public void BernoulliDistribution_Value()
{
// arrange
var distr = new BernoulliDistribution();
distr.Params = new BernoulliDistribution.Parameters(0.3D);
// act
var v0 = distr.Value(0);
var v1 = distr.Value(1);
// assert
Assert.AreEqual(0.7D, v0);
Assert.AreEqual(0.3D, v1);
}
void startButtons()
{
float multiplier = 1 + m_currentTime / m_timeReductionDelay;
var gen = new StaticRandomGenerator <DefaultRandomGenerator>();
float multiButtonProbability = Mathf.Min(m_maxMultipleButtonChance, m_multipleButtonChance * multiplier);
var dMultibutton = new BernoulliDistribution(multiButtonProbability);
var dButtons = new UniformIntDistribution(m_buttons.Count - 1);
do
{
m_buttons[dButtons.Next(gen)].startButton(m_buttonActionTime);
}while (dMultibutton.Next(gen));
selectNextDelay();
}
static void Main(string[] args)
{
Console.WriteLine("Введите вероятность p: ");
var p = double.Parse(Console.ReadLine());
Console.WriteLine("Введите n ");
int n = int.Parse(Console.ReadLine());
var bernoulliDist = new BernoulliDistribution(p);
string fileName = "BernoulliDist.txt";
int count = 0;
using (var sw = new StreamWriter(fileName))
{
for (double i = 1; i <= n; i++)
{
double berVarible = bernoulliDist.Next();
if (berVarible == 1)
{
count++;
}
if (i % 10 == 0)
{
sw.WriteLine($"{i} {count / i};");
}
}
}
//Console.WriteLine("Bernoulli dist");
//Console.WriteLine($"Total: 1000000, Count: {count}, Count/Total: {count / 1000000}");
//var mu = 0.5;
//var laplaceDist = new LaplaceDistribution(alpha, mu);
//var bigInteger = new BigInteger();
//for (int i = 0; i < 1000000; i++)
//{
// var laplaceVarible = laplaceDist.NextDouble();
// bigInteger += (int)laplaceVarible;
//}
//Console.WriteLine("Laplace dist");
//Console.WriteLine($"Total: 1000000, Count: {bigInteger}, Count/Total: {(double)bigInteger / 1000000.0}");
}
public void TestBernoulliDistribution()
{
double[][] para =
{
new double[] { 0.75, 0, 0, 0.2500000000000000000000000, 0.2500000000000000000000000 }
};
for (int i = 0; i < para.Length; i++)
{
var tester = new DiscDistTester(para[i], delegate(double a, double b)
{
var ret = new BernoulliDistribution
{
Probability = a
};
return(ret);
}
);
tester.Test(1E-14);
}
}
public void MedianTest()
{
{
BernoulliDistribution target = new BernoulliDistribution(0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(0.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(1.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
public void MedianTest()
{
{
// Special case for the Bernoulli distribution: while the median is 0.5,
// the inverse distribution function cannot return a double value and thus
// returns 1.
BernoulliDistribution target = new BernoulliDistribution(0.5);
int icdf = target.InverseDistributionFunction(0.5);
Assert.AreEqual(0, icdf);
Assert.AreEqual(0.5, target.Median);
// However, it should work if the Bernoulli is being used as a continuous distribution:
Assert.AreEqual(0.5, (target as IUnivariateDistribution).InverseDistributionFunction(0.5));
Assert.AreEqual(0.5, (target as IUnivariateDistribution <double>).InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(0.2);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(0.6);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(0.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
{
BernoulliDistribution target = new BernoulliDistribution(1.0);
Assert.AreEqual(target.Median, target.InverseDistributionFunction(0.5));
}
}
void spawn()
{
GameObject objectToSpawn = m_redBall;
if (m_spawnedPink == null)
{
objectToSpawn = m_pinkBall;
}
if (m_spawnedGreen == null)
{
objectToSpawn = m_greenBall;
}
if (m_spawnedBlue == null)
{
objectToSpawn = m_blueBall;
}
float redProbability = m_totalSpawnCount > m_spawnLimit ? m_redProbability : m_redProbability * ((float)m_totalSpawnCount / m_spawnLimit);
if (m_spawnedPink != null && m_spawnedGreen != null && m_spawnedBlue != null)
{
redProbability = m_redProbability;
}
bool toRed = new BernoulliDistribution(redProbability).Next(new StaticRandomGenerator <DefaultRandomGenerator>());
if (objectToSpawn == m_redBall && !toRed)
{
m_timer = m_spawnTime;
return;
}
if (objectToSpawn != m_redBall && toRed)
{
objectToSpawn = m_redBall;
}
m_spawning = true;
DOVirtual.DelayedCall(m_spawnDelay, () =>
{
var obj = Instantiate(objectToSpawn, new Vector3(transform.position.x, m_spawnHeight, -0.5f), Quaternion.identity);
var comp = obj.GetComponent <BallLogic>();
if (comp != null)
{
comp.setPath(m_possiblePath[new UniformIntDistribution(m_possiblePath.Count - 1).Next(new StaticRandomGenerator <DefaultRandomGenerator>())]);
}
if (objectToSpawn == m_pinkBall)
{
m_spawnedPink = obj;
}
if (objectToSpawn == m_greenBall)
{
m_spawnedGreen = obj;
}
if (objectToSpawn == m_blueBall)
{
m_spawnedBlue = obj;
}
m_timer = m_spawnTime;
m_totalSpawnCount++;
DOVirtual.DelayedCall(m_spawnDelay, () => m_spawning = false);
});
}
public ValueType Sample()
{
var bernoulli = new BernoulliDistribution(_probability);
return(bernoulli.Sample(rand));
}
/// <summary>
/// Sets the distribution for operations using the current genrator
/// </summary>
/// <param name="distx">Distx.</param>
public void setDistribution(distributions distx, Dictionary <string, double> args)
{
//TODO check arguments to ensure they are making a change to the distribution
//otherwise throw an exception see laplace as a example of implementing this
switch (distx)
{
case distributions.Bernoili:
BernoulliDistribution x0 = new BernoulliDistribution(gen);
if (args.ContainsKey("alpha"))
{
x0.Alpha = args["alpha"];
}
else
{
throw new System.Exception("for Bernoili distribution you must provide an alpha");
}
dist = x0;
break;
case distributions.Beta:
BetaDistribution x1 = new BetaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x1.Alpha = args["alpha"];
x1.Beta = args["beta"];
}
else
{
throw new System.Exception(" for beta distribution you must provide alpha and beta");
}
dist = x1;
break;
case distributions.BetaPrime:
BetaPrimeDistribution x2 = new BetaPrimeDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x2.Alpha = args["alpha"];
x2.Beta = args["beta"];
}
else
{
throw new System.Exception(" for betaPrime distribution you must provide alpha and beta");
}
dist = x2;
break;
case distributions.Cauchy:
CauchyDistribution x3 = new CauchyDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("gamma"))
{
x3.Alpha = args["alpha"];
x3.Gamma = args["gamma"];
}
else
{
throw new System.Exception("for cauchy dist you must provide alpha and gamma");
}
dist = x3;
break;
case distributions.Chi:
ChiDistribution x4 = new ChiDistribution(gen);
if (args.ContainsKey("alpha"))
{
x4.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chi you must provide alpha");
}
dist = x4;
break;
case distributions.ChiSquared:
ChiSquareDistribution x5 = new ChiSquareDistribution(gen);
if (args.ContainsKey("alpha"))
{
x5.Alpha = (int)args["alpha"];
}
else
{
throw new System.Exception("for chiSquared you must provide alpha");
}
dist = x5;
break;
case distributions.ContinuousUniform:
ContinuousUniformDistribution x6 = new ContinuousUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x6.Alpha = args["alpha"];
x6.Beta = args["beta"];
}
else
{
throw new System.Exception("for ContinuousUniform you must provide alpha and beta");
}
dist = x6;
break;
case distributions.DiscreteUniform:
DiscreteUniformDistribution x7 = new DiscreteUniformDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x7.Alpha = (int)args["alpha"];
x7.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for discrete uniform distribution you must provide alpha and beta");
}
dist = x7;
break;
case distributions.Erlang:
ErlangDistribution x8 = new ErlangDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x8.Alpha = (int)args["alpha"];
x8.Lambda = (int)args["lambda"];
}
else
{
throw new System.Exception("for Erlang dist you must provide alpha and lambda");
}
dist = x8;
break;
case distributions.Exponential:
ExponentialDistribution x9 = new ExponentialDistribution(gen);
if (args.ContainsKey("lambda"))
{
x9.Lambda = args["lambda"];
}
else
{
throw new System.Exception("for exponential dist you must provide lambda");
}
dist = x9;
break;
case distributions.FisherSnedecor:
FisherSnedecorDistribution x10 = new FisherSnedecorDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x10.Alpha = (int)args["alpha"];
x10.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("for FisherSnedecor you must provide alpha and beta");
}
dist = x10;
break;
case distributions.FisherTippett:
FisherTippettDistribution x11 = new FisherTippettDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
x11.Alpha = args["alpha"];
x11.Mu = args["mu"];
}
else
{
throw new System.Exception("for FisherTippets you must provide alpha and mu");
}
dist = x11;
break;
case distributions.Gamma:
GammaDistribution x12 = new GammaDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("theta"))
{
x12.Alpha = args["alpha"];
x12.Theta = args["theta"];
}
else
{
throw new System.Exception("for Gamma dist you must provide alpha and theta");
}
dist = x12;
break;
case distributions.Geometric:
GeometricDistribution x13 = new GeometricDistribution(gen);
if (args.ContainsKey("alpha"))
{
x13.Alpha = args["alpha"];
}
else
{
throw new System.Exception("Geometric distribution requires alpha value");
}
dist = x13;
break;
case distributions.Binomial:
BinomialDistribution x14 = new BinomialDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x14.Alpha = args["alpha"];
x14.Beta = (int)args["beta"];
}
else
{
throw new System.Exception("binomial distribution requires alpha and beta");
}
dist = x14;
break;
case distributions.None:
break;
case distributions.Laplace:
LaplaceDistribution x15 = new LaplaceDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("mu"))
{
if (x15.IsValidAlpha(args["alpha"]) && x15.IsValidMu(args["mu"]))
{
x15.Alpha = args["alpha"];
x15.Mu = args["mu"];
}
else
{
throw new ArgumentException("alpha must be greater than zero");
}
}
else
{
throw new System.Exception("Laplace dist requires alpha and mu");
}
dist = x15;
break;
case distributions.LogNormal:
LognormalDistribution x16 = new LognormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x16.Mu = args["mu"];
x16.Sigma = args["sigma"];
}
else
{
throw new System.Exception("lognormal distribution requires mu and sigma");
}
dist = x16;
break;
case distributions.Normal:
NormalDistribution x17 = new NormalDistribution(gen);
if (args.ContainsKey("mu") && args.ContainsKey("sigma"))
{
x17.Mu = args["mu"];
x17.Sigma = args["sigma"];
}
else
{
throw new System.Exception("normal distribution requires mu and sigma");
}
dist = x17;
break;
case distributions.Pareto:
ParetoDistribution x18 = new ParetoDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x18.Alpha = args["alpha"];
x18.Beta = args["beta"];
}
else
{
throw new System.Exception("pareto distribution requires alpha and beta");
}
dist = x18;
break;
case distributions.Poisson:
PoissonDistribution x19 = new PoissonDistribution(gen);
if (args.ContainsKey("lambda"))
{
x19.Lambda = args["lambda"];
}
else
{
throw new System.Exception("Poisson distribution requires lambda");
}
dist = x19;
break;
case distributions.Power:
PowerDistribution x20 = new PowerDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta"))
{
x20.Alpha = args["alpha"];
x20.Beta = args["beta"];
}
else
{
throw new System.Exception("Power dist requires alpha and beta");
}
dist = x20;
break;
case distributions.RayLeigh:
RayleighDistribution x21 = new RayleighDistribution(gen);
if (args.ContainsKey("sigma"))
{
x21.Sigma = args["sigma"];
}
else
{
throw new System.Exception("Rayleigh dist requires sigma");
}
dist = x21;
break;
case distributions.StudentsT:
StudentsTDistribution x22 = new StudentsTDistribution(gen);
if (args.ContainsKey("nu"))
{
x22.Nu = (int)args["nu"];
}
else
{
throw new System.Exception("StudentsT dist requirres nu");
}
dist = x22;
break;
case distributions.Triangular:
TriangularDistribution x23 = new TriangularDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("beta") && args.ContainsKey("gamma"))
{
x23.Alpha = args["alpha"];
x23.Beta = args["beta"];
x23.Gamma = args["gamma"];
}
else
{
throw new System.Exception("Triangular distribution requires alpha, beta and gamma");
}
dist = x23;
break;
case distributions.WeiBull:
WeibullDistribution x24 = new WeibullDistribution(gen);
if (args.ContainsKey("alpha") && args.ContainsKey("lambda"))
{
x24.Alpha = args["alpha"];
x24.Lambda = args["lambda"];
}
else
{
throw new System.Exception("WeiBull dist requires alpha and lambda");
}
dist = x24;
break;
default:
throw new NotImplementedException("the distribution you want has not yet been implemented " +
"you could help everyone out by going and implementing it");
}
}