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 void Roll_ReturnValueBasedOnProbabilityDistribution()
{
// Setup
var spec = new[]
{
new ValueProbabilityPair(0, 0.5),
new ValueProbabilityPair(1, 0.5),
};
var distribution = new DiscreteValueProbabilityDistribution(spec);
var expectedValueAndProbabilities = new[]
{
Tuple.Create(0, 0.0),
Tuple.Create(0, 0.324),
Tuple.Create(0, 0.5),
Tuple.Create(1, 0.5 + 1e-6),
Tuple.Create(1, 0.75),
Tuple.Create(1, 1.0),
};
var rng = new TestingRandomNumberGenerator();
rng.AddFactorValues(expectedValueAndProbabilities.Select(t => t.Item2));
AbstractDie die = new TestAbstractDie(rng, distribution);
foreach (Tuple <int, double> tuple in expectedValueAndProbabilities)
{
// Call
int rollResult = die.Roll();
// Assert
Assert.AreEqual(tuple.Item1, rollResult);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NumericalDie"/> class.
/// </summary>
/// <param name="numberOfSides">The number of sides the die has.</param>
/// <param name="rng">The random number generator.</param>
public NumericalDie(int numberOfSides, IRandomNumberGenerator rng)
: base(rng)
{
NumberOfSides = numberOfSides;
ValueProbabilityPair[] dieProbabilities = CreateProbabilityDistribution(numberOfSides);
ProbabilityDistribution = new DiscreteValueProbabilityDistribution(dieProbabilities);
Debug.Assert(NumberOfSides == numberOfSides, "The property NumberOfSides should be initialized with the given argument.");
}
private static void AssertExpectedDistribution(int numberOfSides, DiscreteValueProbabilityDistribution actualDistribution)
{
var rng = MockRepository.GenerateStub <IRandomNumberGenerator>();
var die = new NumericalDie(numberOfSides, rng);
DiscreteValueProbabilityDistribution expectedDistribution = die.ProbabilityDistribution;
AssertEquals(expectedDistribution, actualDistribution);
}
private static void AssertEquals(DiscreteValueProbabilityDistribution expectedDistribution, DiscreteValueProbabilityDistribution actualDistribution)
{
Assert.AreEqual(expectedDistribution.Specification.Count, actualDistribution.Specification.Count);
for (int i = 0; i < expectedDistribution.Specification.Count; i++)
{
Assert.AreEqual(expectedDistribution.Specification[i].Value, actualDistribution.Specification[i].Value);
Assert.AreEqual(expectedDistribution.Specification[i].Probability, actualDistribution.Specification[i].Probability);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SumOfDice"/> class.
/// </summary>
/// <param name="dice">The dice that define this object.</param>
/// <param name="rng">The random number generator.</param>
public SumOfDice(IEnumerable <IAbstractDie> dice, IRandomNumberGenerator rng)
: base(rng)
{
Debug.Assert(dice != null, "The collection of dice cannot be null.");
Debug.Assert(dice.All(die => die != null), "The collection of dice cannot contain null.");
Debug.Assert(dice.Count() > 0, "The collection of dice must contain at least 1 element.");
this.dice = dice.ToArray();
ValueProbabilityPair[] probabilitySpecification = CreateProbabilityDistribution(this.dice);
ProbabilityDistribution = new DiscreteValueProbabilityDistribution(probabilitySpecification);
}
private static void AssertExpectedDistribution(int numberOfDice, int numberOfSides, DiscreteValueProbabilityDistribution actualDistribution)
{
var rng = MockRepository.GenerateStub <IRandomNumberGenerator>();
IEnumerable <NumericalDie> dice = Enumerable.Repeat(numberOfSides, numberOfDice)
.Select(nrOfSides => new NumericalDie(nrOfSides, rng));
var sumOfDice = new SumOfDice(dice, rng);
DiscreteValueProbabilityDistribution expectedDistribution = sumOfDice.ProbabilityDistribution;
AssertEquals(expectedDistribution, actualDistribution);
}
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 GetValueAtCdf_ForWholeSpectrum_ReturnExpectedValuesAccoringToDistribution(double probability, int expectedValue)
{
// Setup
var valueProbabilityPairs = new[]
{
new ValueProbabilityPair(1, 0.5),
new ValueProbabilityPair(2, 0.25),
new ValueProbabilityPair(3, 0.10),
new ValueProbabilityPair(4, 0.15 - 1e-8),
};
var distribution = new DiscreteValueProbabilityDistribution(valueProbabilityPairs);
// Call
int sampleValue = distribution.GetValueAtCdf(probability);
// Assert
Assert.AreEqual(expectedValue, sampleValue);
}
public void Distribution_SetValue_UpdatePlotModel()
{
// Setup
var viewModel = new ProbabilityDensityFunctionChartViewModel();
var distribution = new DiscreteValueProbabilityDistribution(new[]
{
new ValueProbabilityPair(1, 0.25),
new ValueProbabilityPair(2, 0.50),
new ValueProbabilityPair(3, 0.25),
});
// Call
viewModel.Distribution = distribution;
// Assert
AssertPlotModelForExpectedDistribution(distribution, viewModel.Title, viewModel.ValueName, viewModel.PlotModel);
}
private void AssertPlotModelForExpectedDistribution(
DiscreteValueProbabilityDistribution expectedDistribution,
string expectedTitle,
string expectedValueName,
PlotModel plotModel)
{
Assert.AreEqual(expectedTitle, plotModel.Title);
Assert.IsFalse(plotModel.IsLegendVisible);
Assert.AreEqual(2, plotModel.Axes.Count);
var horizontalAxis = (CategoryAxis)plotModel.Axes[0];
Assert.AreEqual(expectedValueName, horizontalAxis.Title);
Assert.AreEqual(AxisPosition.Bottom, horizontalAxis.Position);
Assert.AreEqual(-1, horizontalAxis.AbsoluteMinimum);
Assert.AreEqual(expectedDistribution == null ? double.MaxValue : expectedDistribution.Specification.Count, horizontalAxis.AbsoluteMaximum);
Assert.IsFalse(horizontalAxis.IsZoomEnabled);
Assert.IsFalse(horizontalAxis.IsPanEnabled);
Assert.AreEqual(0.0, horizontalAxis.GapWidth);
AssertItemSource(expectedDistribution, horizontalAxis.ItemsSource);
Assert.AreEqual(nameof(ValueProbabilityPair.Value), horizontalAxis.LabelField);
var verticalAxis = (LinearAxis)plotModel.Axes[1];
Assert.AreEqual("Probability", verticalAxis.Title);
Assert.AreEqual(AxisPosition.Left, verticalAxis.Position);
Assert.AreEqual(0.0, verticalAxis.AbsoluteMinimum);
Assert.AreEqual(1.0, verticalAxis.AbsoluteMaximum);
Assert.AreEqual(0.0, verticalAxis.Minimum);
Assert.AreEqual(1.0, verticalAxis.Maximum);
Assert.IsFalse(verticalAxis.IsZoomEnabled);
Assert.IsFalse(verticalAxis.IsPanEnabled);
Assert.AreEqual("p", verticalAxis.StringFormat);
Assert.AreEqual(1, plotModel.Series.Count);
ColumnSeries series = (ColumnSeries)plotModel.Series[0];
Assert.AreEqual($"{expectedValueName} probability", series.Title);
AssertItemSource(expectedDistribution, horizontalAxis.ItemsSource);
Assert.AreEqual(nameof(ValueProbabilityPair.Probability), series.ValueField);
Assert.AreEqual(OxyColors.DarkCyan, series.FillColor);
Assert.AreEqual("{0}\n{1}: {2:p}", series.TrackerFormatString);
}
public void ProbabilityDistribution_ForSomeNumberOfSides_DefinesUniformProbabilityDistribution(int numberOfSides)
{
// Setup
var rng = MockRepository.GenerateStub <IRandomNumberGenerator>();
var die = new NumericalDie(numberOfSides, rng);
// Call
DiscreteValueProbabilityDistribution distribution = die.ProbabilityDistribution;
// Assert
double uniformProbability = 1.0 / numberOfSides;
foreach (ValueProbabilityPair pair in distribution.Specification)
{
Assert.AreEqual(uniformProbability, pair.Probability);
}
CollectionAssert.AreEquivalent(Enumerable.Range(1, numberOfSides), distribution.Specification.Select(p => p.Value));
}
private static void AssertItemSource(DiscreteValueProbabilityDistribution expectedDistribution, IEnumerable itemSource)
{
if (expectedDistribution == null)
{
CollectionAssert.IsEmpty(itemSource);
}
else
{
var valueProbabilities = (IList <ValueProbabilityPair>)itemSource;
IList <ValueProbabilityPair> expectedProbabilities = expectedDistribution.Specification;
Assert.AreEqual(expectedProbabilities.Count, valueProbabilities.Count);
for (int i = 0; i < expectedProbabilities.Count; i++)
{
Assert.AreEqual(expectedProbabilities[i].Value, valueProbabilities[i].Value);
Assert.AreEqual(expectedProbabilities[i].Probability, valueProbabilities[i].Probability);
}
}
}
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);
}
}
public TestAbstractDie(IRandomNumberGenerator rng, DiscreteValueProbabilityDistribution distribution)
: base(rng)
{
ProbabilityDistribution = distribution;
}
