internal void Evaluate_WithThreeGroupCompoundStatement_ReturnsExpectedResult()
{
// Arrange
var evaluator = new FuzzyEvaluator();
var evaluations = new List <Evaluation>
{
// Statement group 1 (assumed to evaluate to 0).
new Evaluation(LogicOperators.If(), UnitInterval.Create(0.25)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.0)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.2)),
// Statement group 2 (assumed to evaluate to 0.8).
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.8)),
// Statement group 3 (assumed to evaluate to 0.9).
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1))
};
// Act
var result = evaluator.Evaluate(evaluations);
// Assert
Assert.Equal(UnitInterval.Create(0.9), result);
}
internal void Evaluate_WithThreeGroupCompoundStatementAndEinsteinFunctions_ReturnsExpectedResult()
{
// Arrange
var tnorm = TriangularNormFactory.EinsteinProduct();
var tconorm = TriangularConormFactory.EinsteinSum();
var evaluator = new FuzzyEvaluator(tnorm, tconorm);
var evaluations = new List <Evaluation>
{
// Statement group 1
new Evaluation(LogicOperators.If(), UnitInterval.Create(0.25)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.0)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.2)),
// Statement group 2
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.8)),
// Statement group 3
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.5)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1))
};
// Act
var result = evaluator.Evaluate(evaluations);
// Assert
Assert.Equal(0.891304347826087, result.Value);
}
internal void Evaluate_WithFourGroupCompoundStatementThenConnectedByMultipleOrs_ReturnsExpectedResult()
{
// Arrange
var evaluator = new FuzzyEvaluator();
var evaluations = new List <Evaluation>
{
// Statement group 1 (assumed to evaluate to 0.9).
new Evaluation(LogicOperators.If(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.9)),
// Statement group 2 (assumed to evaluate to 0.8).
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.8)),
// Statement group 3 (assumed to evaluate to 0.7).
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.7)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.7)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.7)),
// Then multiple or connectives (assumed to evaluate to 1).
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.8)),
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1))
};
// Act
var result = evaluator.Evaluate(evaluations);
// Assert
Assert.Equal(UnitInterval.Create(1), result);
}
internal void Evaluate_WithThreeGroupCompoundStatementAndOtherFunctions_ReturnsExpectedResult()
{
// Arrange
var tnorm = TriangularNormFactory.Lukasiewicz();
var tconorm = TriangularConormFactory.ProbabilisticSum();
var evaluator = new FuzzyEvaluator(tnorm, tconorm);
var evaluations = new List <Evaluation>
{
// Statement group 1
new Evaluation(LogicOperators.If(), UnitInterval.Create(0.25)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.0)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.2)),
// Statement group 2
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.9)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(0.8)),
// Statement group 3
new Evaluation(LogicOperators.Or(), UnitInterval.Create(0.5)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1)),
new Evaluation(LogicOperators.And(), UnitInterval.Create(1))
};
// Act
var result = evaluator.Evaluate(evaluations);
// Assert
Assert.Equal(0.85, Math.Round(result.Value, 2));
}
/// <summary>
/// Adds a <see cref="Condition"/> to the <see cref="FuzzyRule"/> to be built.
/// </summary>
/// <param name="condition">
/// The condition.
/// </param>
/// <returns>
/// The <see cref="FuzzyRuleBuilder"/>.
/// </returns>
public FuzzyRuleBuilder Or(ConditionBuilder condition)
{
Validate.NotNull(condition, nameof(condition));
condition.Connective = LogicOperators.Or();
this.conditions.Add(condition.Build());
return(this);
}
internal void Evaluate_WithVariousValues_ReturnsExpectedResult(double membership, double expected)
{
// Arrange
var isOperator = LogicOperators.Is();
// Act
var result = isOperator.Evaluate(UnitInterval.Create(membership));
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
/// <summary>
/// Adds a <see cref="Condition"/> to the <see cref="FuzzyRule"/> to be built.
/// </summary>
/// <param name="proposition">
/// The proposition.
/// </param>
/// <returns>
/// A <see cref="FuzzyRuleBuilder"/>.
/// </returns>
public FuzzyRuleBuilder And(Proposition proposition)
{
Validate.NotNull(proposition, nameof(proposition));
var condition = ConditionBuilder.If(proposition);
condition.Connective = LogicOperators.And();
this.conditions.Add(condition.Build());
return(this);
}
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);
}
/// <summary>
/// Adds an 'And' premise to the condition builder.
/// </summary>
/// <param name="proposition">
/// The proposition.
/// </param>
/// <returns>
/// A <see cref="Condition"/>.
/// </returns>
public ConditionBuilder And(Proposition proposition)
{
Utility.Validate.NotNull(proposition, nameof(proposition));
this.Premises.Add(new Premise(
LogicOperators.And(),
proposition.Variable,
proposition.Evaluator,
proposition.State));
return(this);
}
public static string GetLogicOperatorString(LogicOperators opr)
{
switch (opr)
{
case LogicOperators.FirstCondition:
return(String.Empty);
case LogicOperators.And:
return(" AND ");
case LogicOperators.Or:
return(" OR ");
default: return("");
}
}
/// <summary>
/// The create.
/// </summary>
/// <param name="proposition">
/// The proposition.
/// </param>
/// <returns>
/// The <see cref="ConditionBuilder"/>.
/// </returns>
public static ConditionBuilder If(Proposition proposition)
{
Utility.Validate.NotNull(proposition, nameof(proposition));
var conditionBuilder = new ConditionBuilder {
Connective = LogicOperators.If()
};
conditionBuilder.Premises.Add(new Premise(
LogicOperators.If(),
proposition.Variable,
proposition.Evaluator,
proposition.State));
return(conditionBuilder);
}
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_WithTwoEvaluationsOrConnective_ReturnsExpectedResult()
{
// Arrange
var evaluator = new FuzzyEvaluator();
var evaluations = new List <Evaluation>
{
new Evaluation(LogicOperators.If(), UnitInterval.Create(0.25)),
new Evaluation(LogicOperators.Or(), UnitInterval.Create(1))
};
// Act
var result = evaluator.Evaluate(evaluations);
// Assert
Assert.Equal(UnitInterval.Create(1), result);
}
/// <summary>
/// Returns the final evaluation result of the aggregated collection of evaluations.
/// </summary>
/// <param name="evaluations">
/// The evaluations.
/// </param>
/// <returns>
/// A <see cref="UnitInterval"/>.
/// </returns>
public UnitInterval Evaluate(IEnumerable <Evaluation> evaluations)
{
var result = UnitInterval.One();
foreach (var evaluation in evaluations)
{
if (evaluation.Connective.Equals(LogicOperators.And()) ||
evaluation.Connective.Equals(LogicOperators.If()))
{
result = this.And(result, evaluation.Result);
}
if (evaluation.Connective.Equals(LogicOperators.Or()))
{
result = this.Or(result, evaluation.Result);
}
}
return(result);
}
private static void ValidateFuzzyRule(IList <Condition> conditions, IList <Conclusion> conclusions)
{
Validate.CollectionNotNullOrEmpty(conditions, nameof(conditions));
Validate.CollectionNotNullOrEmpty(conclusions, nameof(conclusions));
if (conditions[0].Connective.ToString() != LogicOperators.If().ToString())
{
throw new InvalidOperationException(
$"Invalid FuzzyRule (the connective of the first condition must be an IF). Value = {conditions[0].Connective}.");
}
var remainingConditions = new List <Condition>(conditions);
remainingConditions.RemoveAt(0);
if (remainingConditions.Any(conclusion => conclusion.Connective.Equals(LogicOperators.If())))
{
throw new InvalidOperationException(
$"Invalid FuzzyRule (only the connective of the first condition can be an IF).");
}
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="condition">The <see cref="ICondition"/> that should be represented visually</param>
public ComplexConditionViewModel(ICondition condition)
{
Condition = condition;
Condition.Children?.ForEach(cond =>
{
if (cond is SimpleCondition)
{
Children.Add(new SimpleConditionViewModel(cond));
}
else if (cond is ComplexCondition)
{
Children.Add(new ComplexConditionViewModel(cond));
}
});
Condition.LogicOperators?.ForEach(logOp =>
{
LogicOperators.Add(logOp);
});
ExpandCommand = new RelayCommand(Expand, CanExpand);
}
public Condition(LogicOperators logicOperator, string lhs, RelationalOperators relationalOperator, string rhs) :
this(lhs, relationalOperator, rhs)
{
LOp = logicOperators[logicOperator];
}
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));
}
/// <summary>
/// Returns a proposition based on whether the variable IS NOT in the given state.
/// </summary>
/// <param name="state">
/// The state.
/// </param>
/// <returns>
/// The <see cref="Proposition"/>.
/// </returns>
public Proposition Not(FuzzyState state)
{
return(new Proposition(this, LogicOperators.IsNot(), state));
}
public static bool CompareValue(LogicOperators Operator, int Value1, int Value2)
{
switch (Operator)
{
case LogicOperators.Equal:
if (Value1 == Value2)
{
return(true);
}
else
{
return(false);
}
case LogicOperators.Greater:
if (Value1 > Value2)
{
return(true);
}
else
{
return(false);
}
case LogicOperators.GreaterOrEqual:
if (Value1 >= Value2)
{
return(true);
}
else
{
return(false);
}
case LogicOperators.Lower:
if (Value1 < Value2)
{
return(true);
}
else
{
return(false);
}
case LogicOperators.LowerOrEqual:
if (Value1 <= Value2)
{
return(true);
}
else
{
return(false);
}
case LogicOperators.NotEqual:
if (Value1 != Value2)
{
return(true);
}
else
{
return(false);
}
}
return(false);
}
