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 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 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);
}
internal void RunMamdaniInference(double foodInput, double serviceInput, double expected)
{
// Define the input and output linguistic variables.
var foodQuality = new LinguisticVariable(
InputVariable.FoodQuality,
new List <FuzzySet>
{
new FuzzySet(FoodQuality.Poor, TrapezoidalFunction.CreateWithLeftEdge(0, 5)),
new FuzzySet(FoodQuality.Average, TriangularFunction.Create(0, 5, 10)),
new FuzzySet(FoodQuality.Good, TrapezoidalFunction.CreateWithRightEdge(5, 10))
});
var serviceQuality = new LinguisticVariable(
InputVariable.FoodQuality,
new List <FuzzySet>
{
new FuzzySet(ServiceQuality.Poor, TrapezoidalFunction.CreateWithLeftEdge(0, 5)),
new FuzzySet(ServiceQuality.Average, TriangularFunction.Create(0, 5, 10)),
new FuzzySet(ServiceQuality.Good, TrapezoidalFunction.CreateWithRightEdge(5, 10))
});
var tipAmount = new LinguisticVariable(
OutputVariable.TipAmount,
new List <FuzzySet>
{
new FuzzySet(TipAmount.Low, TrapezoidalFunction.CreateWithLeftEdge(0, 13)),
new FuzzySet(TipAmount.Medium, TriangularFunction.Create(0, 13, 25)),
new FuzzySet(TipAmount.High, TrapezoidalFunction.CreateWithRightEdge(13, 25))
});
// Define the rules for the fuzzy inference engine.
var rule1 = new FuzzyRuleBuilder(TippingProblem.Rule1)
.If(foodQuality.Is(FoodQuality.Poor))
.Or(serviceQuality.Is(ServiceQuality.Poor))
.Then(tipAmount.Is(TipAmount.Low))
.Build();
var rule2 = new FuzzyRuleBuilder(TippingProblem.Rule2)
.If(serviceQuality.Is(ServiceQuality.Average))
.Then(tipAmount.Is(TipAmount.Medium))
.Build();
var rule3 = new FuzzyRuleBuilder(TippingProblem.Rule3)
.If(foodQuality.Is(FoodQuality.Good))
.Or(serviceQuality.Is(ServiceQuality.Good))
.Then(tipAmount.Is(TipAmount.High))
.Build();
// Construct the fuzzy inference engine.
var tnorm = TriangularNormFactory.MinimumTNorm();
var tconorm = TriangularConormFactory.MaximumTConorm();
var defuzzifier = new CentroidDefuzzifier();
var fuzzyEngine = new MamdaniInferenceEngine(tnorm, tconorm, defuzzifier);
// Add the rules to the rulebase.
fuzzyEngine.Rulebase.AddRule(rule1);
fuzzyEngine.Rulebase.AddRule(rule2);
fuzzyEngine.Rulebase.AddRule(rule3);
// Prepare database to receive inputs.
fuzzyEngine.Database.AddVariable(Label.Create(InputVariable.FoodQuality));
fuzzyEngine.Database.AddVariable(Label.Create(InputVariable.ServiceQuality));
// Generate input data.
var foodData = new DataPoint(InputVariable.FoodQuality, foodInput);
var serviceData = new DataPoint(InputVariable.ServiceQuality, serviceInput);
// Feed inference engine the data.
fuzzyEngine.Database.UpdateData(foodData);
fuzzyEngine.Database.UpdateData(serviceData);
// Compute the inference engine.
var result = fuzzyEngine.Compute();
Assert.Equal(OutputVariable.TipAmount.ToString(), result[0].Subject.Value);
Assert.Equal(expected, result[0].Value);
}
