public void ProbabilityDistribution_OneD3_ReturnExpectedDistribution()
{
// Setup
var rng = MockRepository.GenerateStub <IRandomNumberGenerator>();
var dice = new[]
{
new NumericalDie(3, rng),
};
var sumOf2D6 = new SumOfDice(dice, rng);
// Call
DiscreteValueProbabilityDistribution distribution = sumOf2D6.ProbabilityDistribution;
// Assert
var expectedProbabilityValuePairs = new[]
{
Tuple.Create(1, 1.0 / 3.0),
Tuple.Create(2, 1.0 / 3.0),
Tuple.Create(3, 1.0 / 3.0),
};
Assert.AreEqual(expectedProbabilityValuePairs.Length, distribution.Specification.Count);
for (int i = 0; i < expectedProbabilityValuePairs.Length; i++)
{
Tuple <int, double> expectedPair = expectedProbabilityValuePairs[i];
ValueProbabilityPair actualPair = distribution.Specification[i];
Assert.AreEqual(expectedPair.Item1, actualPair.Value);
Assert.AreEqual(expectedPair.Item2, actualPair.Probability, 1e-6);
}
}
public static void Constructor_ValidArguments_ExpectedValue(
[Values(int.MinValue, -5467, 0, 89754, int.MaxValue)] int value,
[Values(0.0, 0.345, 1.0)] double probability)
{
// Call
var pair = new ValueProbabilityPair(value, probability);
// Setup
Assert.AreEqual(value, pair.Value);
Assert.AreEqual(probability, pair.Probability);
}
public void ProbabilityDistribution_ValidArguments_ReturnExpectedResult()
{
// Setup
var randomVariable = MockRepository.GenerateStub <IDiscreteBooleanRandomVariable>();
randomVariable.Stub(rv => rv.ProbabilityDistribution)
.Return(new BooleanProbabilityDistribution(0.25));
var trueCase = MockRepository.GenerateStub <IDiscreteIntegerRandomVariable>();
trueCase.Stub(rv => rv.ProbabilityDistribution)
.Return(new DiscreteValueProbabilityDistribution(new[]
{
new ValueProbabilityPair(1, 0.25),
new ValueProbabilityPair(2, 0.75),
}));
var falseCase = MockRepository.GenerateStub <IDiscreteIntegerRandomVariable>();
falseCase.Stub(rv => rv.ProbabilityDistribution)
.Return(new DiscreteValueProbabilityDistribution(new[]
{
new ValueProbabilityPair(2, 0.5),
new ValueProbabilityPair(4, 0.5),
}));
var conditional = new ConditionalCombination(randomVariable, trueCase, falseCase);
// Call
DiscreteValueProbabilityDistribution distribution = conditional.ProbabilityDistribution;
// Assert
Assert.AreEqual(3, distribution.Specification.Count);
var probabilitiesAndValues = new Tuple <double, int>[]
{
Tuple.Create(0.25 * 0.25, 1),
Tuple.Create((0.25 * 0.75) + (0.75 * 0.5), 2),
Tuple.Create(0.75 * 0.5, 4),
};
for (int i = 0; i < probabilitiesAndValues.Length; i++)
{
Tuple <double, int> expectedProbabilityAndValue = probabilitiesAndValues[i];
ValueProbabilityPair actualProbabilityAndValue = distribution.Specification[i];
Assert.AreEqual(expectedProbabilityAndValue.Item1, actualProbabilityAndValue.Probability);
Assert.AreEqual(expectedProbabilityAndValue.Item2, actualProbabilityAndValue.Value);
}
}
public void ProbabilityDistribution_AddingValueTo1D6_ReturnExpectedDistribution(int modifierValue)
{
// Setup
var rng = MockRepository.GenerateStub <IRandomNumberGenerator>();
var die = new NumericalDie(6, rng);
var modifier = new DiceModifier(die, modifierValue, rng);
// Call
DiscreteValueProbabilityDistribution distribution = modifier.ProbabilityDistribution;
// Assert
ReadOnlyCollection <ValueProbabilityPair> specification = die.ProbabilityDistribution.Specification;
Assert.AreEqual(specification.Count, distribution.Specification.Count);
for (int i = 0; i < specification.Count; i++)
{
ValueProbabilityPair referencePair = specification[i];
ValueProbabilityPair actualPair = distribution.Specification[i];
Assert.AreEqual(referencePair.Probability, actualPair.Probability);
Assert.AreEqual(referencePair.Value + modifierValue, actualPair.Value);
}
}
public void Constructor_ValidDistributionSpecified_ExpectedValues()
{
// Setup
var valueProbabilityPairs = new[]
{
new ValueProbabilityPair(1, 0.5),
new ValueProbabilityPair(2, 0.25),
new ValueProbabilityPair(3, 0.10),
new ValueProbabilityPair(4, 0.15),
};
// Call
var distribution = new DiscreteValueProbabilityDistribution(valueProbabilityPairs);
// Assert
ReadOnlyCollection <ValueProbabilityPair> specification = distribution.Specification;
Assert.AreEqual(valueProbabilityPairs.Length, specification.Count);
foreach (ValueProbabilityPair expectedPair in valueProbabilityPairs)
{
ValueProbabilityPair pair = specification.Single(s => s.Value == expectedPair.Value);
Assert.AreEqual(expectedPair.Probability, pair.Probability);
}
}
