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));
}
public void computeAtom()
{
string testString = "23.5";
Tokenizer tokened = Tokenizer.tokenize(testString);
Assert.AreEqual(23.5, FuzzyEvaluator.computeAtom(tokened, FuzzyOperator.MinMax));
}
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_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_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);
}
/// <summary>
/// Evaluates the fuzzy condition.
/// </summary>
/// <param name="data">
/// The data.
/// </param>
/// <param name="evaluator">
/// The evaluator.
/// </param>
/// <returns>
/// A <see cref="double"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// Throws if provided data does not contain all subjects.
/// </exception>
public Evaluation Evaluate(
IReadOnlyDictionary <Label, DataPoint> data,
FuzzyEvaluator evaluator)
{
Validate.NotNull(data, nameof(data));
Validate.NotNull(evaluator, nameof(evaluator));
var evaluations = new List <Evaluation>();
foreach (var premise in this.Premises)
{
if (data.ContainsKey(premise.Subject))
{
var input = data[premise.Subject];
evaluations.Add(premise.Evaluate(input));
}
else
{
throw new InvalidOperationException(
$"Evaluation Failed (cannot evaluate premise '{premise.Subject}' with provided data).");
}
}
return(new Evaluation(this.Connective, UnitInterval.Create(evaluator.Evaluate(evaluations) * this.Weight)));
}
public void Apply(List <LinguisticVariable> LingVars)
{
string numericRule = this.numericRule(LingVars);
Tokenizer ruleTokens = Tokenizer.tokenize(numericRule);
this.membershipValue.fuzzy = FuzzyEvaluator.computeExpr(ruleTokens, 1, this.fOperator, false);
}
public void computeExpr()
{
string testString = "not 23.5 or ( 3.5 and 0.004 ) and ( 32 or ( 0.3 and 0.012 ) )";
Tokenizer tokened = Tokenizer.tokenize(testString);
double result = FuzzyEvaluator.computeExpr(tokened, 1, FuzzyOperator.Probabilistic, false);
Debug.Log("[Fuzzy Evaluator Calculation Test Result] \n" +
testString + " = " + result);
}
internal void And_WhenFunctionsDefault_ReturnsExpectedResult()
{
// Arrange
var evaluator = new FuzzyEvaluator();
var membershipA = UnitInterval.Create(0.25);
var membershipB = UnitInterval.Create(0.5);
// Act
var result = evaluator.And(membershipA, membershipB);
// Assert
Assert.Equal(UnitInterval.Create(0.25), result);
}
/// <summary>
/// Returns the evaluation of all fuzzy rules in the <see cref="Rulebase"/>.
/// </summary>
/// <param name="rules">
/// The fuzzy rules.
/// </param>
/// <param name="data">
/// The data.
/// </param>
/// <param name="evaluator">
/// The evaluator.
/// </param>
/// <returns>
/// A <see cref="IList{T}"/>.
/// </returns>
protected static IList <FuzzyOutput> EvaluateRules(
IEnumerable <FuzzyRule> rules,
IReadOnlyDictionary <Label, DataPoint> data,
FuzzyEvaluator evaluator)
{
var fuzzyOutputs = new List <FuzzyOutput>();
foreach (var rule in rules)
{
var ruleOutputs = rule.Evaluate(data, evaluator);
ruleOutputs.ForEach(o => fuzzyOutputs.Add(o));
}
return(fuzzyOutputs);
}
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);
}
internal void Or_WhenFunctionsDefault_ReturnsExpectedResult()
{
// Arrange
var tNorm = TriangularNormFactory.MinimumTNorm();
var tConorm = TriangularConormFactory.MaximumTConorm();
var evaluator = new FuzzyEvaluator(tNorm, tConorm);
var membershipA = UnitInterval.Create(0.25);
var membershipB = UnitInterval.Create(0.5);
// Act
var result = evaluator.Or(membershipA, membershipB);
// Assert
Assert.Equal(UnitInterval.Create(0.5), result);
}
