internal void Build_WithComplexCondition_ReturnsExpectedFuzzyRule()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
// Act
var rule1 = new FuzzyRuleBuilder("Rule1")
.If(ConditionBuilder
.If(waterTemp.Is("cold"))
.And(waterTemp.Not("freezing"))
.Or(waterTemp.Not("frozen")))
.And(ConditionBuilder
.If(waterTemp.Is("warm"))
.And(waterTemp.Not("hot"))
.Or(waterTemp.Not("boiling")))
.And(ConditionBuilder
.If(waterTemp.Is("frozen"))
.And(waterTemp.Is("warm")))
.Then(waterTemp.Not("frozen"))
.Build();
var dataPoint = new DataPoint(waterTemp.Subject, 20);
var data = new Dictionary <Label, DataPoint> {
{ dataPoint.Variable, dataPoint }
};
var result = rule1.Evaluate(data, new FuzzyEvaluator());
var temp = waterTemp.GetState(2);
// Assert
//Assert.Equal(new FuzzyState("warm"), temp);
//Assert.True(result);
}
internal void Evaluate_ValidRuleAndConditions_ReturnsExpectedFuzzyOutput()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var fanSpeed = StubLinguisticVariableFactory.PumpSpeed();
var fuzzyRule = new FuzzyRuleBuilder(PumpSpeedRule.Rule0)
.If(ConditionBuilder.If(waterTemp.Is(WaterTemp.Frozen)))
.Or(ConditionBuilder.If(waterTemp.Is(WaterTemp.Freezing)))
.Then(fanSpeed.Is(PumpSpeed.Off))
.Build();
var dataPoint = new DataPoint(waterTemp.Subject, 0);
var data = new Dictionary <Label, DataPoint> {
{ dataPoint.Variable, dataPoint }
};
// Act
var result = fuzzyRule.Evaluate(data, new FuzzyEvaluator());
// Assert
Assert.Equal(fanSpeed.Subject, result[0].Subject);
Assert.Equal(fanSpeed.GetState(0), result[0].State);
Assert.Equal(UnitInterval.One(), result[0].FiringStrength);
Assert.Equal(fanSpeed.GetSet(PumpSpeed.Off), result[0].OutputFunction);
}
internal void IsMember_WhenVariableDoesNotContainMember_ReturnsTrue()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.IsMember(FuzzyState.Create("vapour"));
// Assert
Assert.False(result);
}
internal void GetState_ReturnsExpectedState(double input, Enum state)
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.GetState(input);
// Assert
Assert.Equal(FuzzyState.Create(state), result);
}
internal void GetMembership_ReturnsExpectedDouble(double input, Enum label, double membershipValue)
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.GetMembership(label, input);
// Assert
Assert.Equal(UnitInterval.Create(membershipValue), result);
}
internal void GetUpperBound_ReturnsExpectedDouble()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.UpperBound;
// Assert
Assert.Equal(200, result);
}
internal void GetLabel_ReturnsExpectedLabel()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.Subject;
// Assert
Assert.Equal(Label.Create(InputVariable.WaterTemp), result);
}
internal void GetMembers_ReturnsTheListOfMembers()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.GetMembers();
// Assert
Assert.Equal(6, result.Count);
}
internal void GetSet_ReturnsTheFuzzySet()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.GetSet(WaterTemp.Frozen);
// Assert
Assert.Equal(FuzzyState.Create("frozen"), result.State);
}
internal void IsMember_WhenVariableContainsMember_ReturnsTrue()
{
// Arrange
var temperature = StubLinguisticVariableFactory.WaterTemp();
// Act
var result = temperature.IsMember(WaterTemp.Frozen);
// Assert
Assert.True(result);
}
internal void ValidateProposition_WhenStateNotAMemberOfLinguisticVariable_Throws()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
// Invalid fuzzy state.
var fuzzyState = FuzzyState.Create(PumpSpeed.Off);
// Act
// Assert
Assert.Throws <InvalidOperationException>(() => new Proposition(waterTemp, LogicOperators.Is(), fuzzyState));
}
internal void ToString_ReturnsExpectedString()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var conclusion = new Conclusion(waterTemp, LogicOperators.Is(), FuzzyState.Create(WaterTemp.Cold));
// Act
var result = conclusion.ToString();
// Assert
Assert.Equal("THEN WaterTemp IS cold", result);
}
internal void Validate_WhenFirstConditionConnectiveNotIf_Throws()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var fanSpeed = StubLinguisticVariableFactory.PumpSpeed();
var fuzzyRule = new FuzzyRuleBuilder("Rule0")
.And(ConditionBuilder.If(waterTemp.Is(WaterTemp.Frozen)))
.Then(fanSpeed.Is(PumpSpeed.Off));
// Act
// Assert
var ex = Assert.Throws <InvalidOperationException>(() => fuzzyRule.Build());
this.output.WriteLine(ex.Message);
}
internal void WithWeight_SetsWeightToExpectedValue()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var condition = ConditionBuilder
.If(waterTemp.Is(WaterTemp.Boiling))
.WithWeight(0.5)
.Build();
// Act
condition.SetWeight(UnitInterval.Create(0.5));
// Assert
Assert.Equal(0.5, condition.Weight.Value);
}
internal void ToString_ReturnsExpectedString()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var premise = new Premise(
LogicOperators.If(),
waterTemp,
LogicOperators.Is(),
FuzzyState.Create(WaterTemp.Cold));
// Act
var result = premise.ToString();
// Assert
Assert.Equal("IF WaterTemp IS cold", result);
}
internal void Evaluate_WhenInvalidData_Throws()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var condition = ConditionBuilder.If(waterTemp.Is(WaterTemp.Boiling)).Build();
var dataPoint = new DataPoint(Label.Create(InputVariable.Pressure), 3000);
var data = new Dictionary <Label, DataPoint> {
{ dataPoint.Variable, dataPoint }
};
// Act
// Assert
Assert.Throws <InvalidOperationException>(() => condition.Evaluate(data, new FuzzyEvaluator()));
}
internal void ToString_ReturnsExpectedString()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var condition = ConditionBuilder
.If(waterTemp.Not(WaterTemp.Boiling))
.And(waterTemp.Not(WaterTemp.Freezing))
.And(waterTemp.Not(WaterTemp.Frozen))
.Build();
// Act
var result = condition.ToString();
// Assert
Assert.Equal("IF WaterTemp NOT boiling AND WaterTemp NOT freezing AND WaterTemp NOT frozen", result);
}
internal void Build_WhenConditionsAndConclusionsAreValid_ReturnsExpectedRuzzyRule()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
var pumpSpeed = StubLinguisticVariableFactory.PumpSpeed();
// Act
var fuzzyRule = new FuzzyRuleBuilder(PumpSpeedRule.Rule0)
.If(waterTemp.Is(WaterTemp.Warm))
.And(waterTemp.Not(WaterTemp.Frozen))
.Then(pumpSpeed.Is(PumpSpeed.Moderate))
.Build();
// Assert
Assert.Equal(Label.Create(PumpSpeedRule.Rule0), fuzzyRule.Label);
Assert.Equal(2, fuzzyRule.Conditions.Count);
Assert.Equal(1, fuzzyRule.Conclusions.Count);
}
internal void Build_ValidConditionsAndConclusions_ReturnsExpectedFuzzyRule()
{
// Arrange
var waterTemp = StubLinguisticVariableFactory.WaterTemp();
// Act
var rule1 = new FuzzyRuleBuilder(PumpSpeedRule.Rule0)
.If(ConditionBuilder
.If(waterTemp.Not(WaterTemp.Cold))
.And(waterTemp.Not(WaterTemp.Freezing))
.And(waterTemp.Not(WaterTemp.Frozen)))
.And(ConditionBuilder.If(waterTemp.Is(WaterTemp.Warm)))
.Or(ConditionBuilder.If(waterTemp.Not(WaterTemp.Frozen)).And(waterTemp.Not(WaterTemp.Boiling)))
.Then(waterTemp.Not(WaterTemp.Boiling))
.Then(waterTemp.Not(WaterTemp.Frozen))
.Build();
// Assert
Assert.Equal(3, rule1.Conditions.Count);
Assert.Equal(2, rule1.Conclusions.Count);
}
