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);
}
/// <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)));
}
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);
}
/// <summary>
/// Returns the intersection of the membership value (the minimum membership value of the fuzzy sets).
/// </summary>
/// <param name="other">
/// The other.
/// </param>
/// <param name="x">
/// The x.
/// </param>
/// <returns>
/// The <see cref="double"/>.
/// </returns>
public UnitInterval Intersection(FuzzySet other, double x)
{
Validate.NotNull(other, nameof(other));
Validate.NotOutOfRange(x, nameof(x));
return(UnitInterval.Create(Math.Min(this.function.GetMembership(x).Value, other.GetMembership(x).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);
}
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>
/// The with weight.
/// </summary>
/// <param name="weight">
/// The weight.
/// </param>
/// <returns>
/// The <see cref="ConditionBuilder"/>.
/// </returns>
public ConditionBuilder WithWeight(double weight)
{
Utility.Validate.NotOutOfRange(weight, nameof(weight), 0, 1);
this.Weight = UnitInterval.Create(weight);
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="FuzzyPoint"/> struct.
/// </summary>
/// <param name="x">
/// The X co-ordinate.
/// </param>
/// <param name="y">
/// The Y co-ordinate.
/// </param>
public FuzzyPoint(double x, double y)
{
Validate.NotOutOfRange(x, nameof(x));
Validate.NotOutOfRange(y, nameof(y), 0, 1);
this.X = x;
this.Y = UnitInterval.Create(y);
}
public UnitInterval Evaluate(UnitInterval membershipA, UnitInterval membershipB)
{
return(1 - (membershipA * membershipB) > 0
? UnitInterval.Create(
((membershipA + membershipB) - (2 * (membershipA * membershipB)))
/ (1 - (membershipA * membershipB)))
: UnitInterval.One());
}
public UnitInterval Evaluate(UnitInterval membershipA, UnitInterval membershipB)
{
return((membershipA + membershipB) - (membershipA * membershipB) > 0
? UnitInterval.Create(
(membershipA * membershipB)
/ ((membershipA + membershipB) - (membershipA * membershipB)))
: UnitInterval.Zero());
}
internal void GetMembership_VariousInputs_ReturnsExpectedResult(double x, double input, double expected)
{
// Arrange
var function = SingletonFunction.Create(x);
// Act
var result = function.GetMembership(input);
// Assert
Assert.Equal(UnitInterval.Create(expected), 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 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);
}
internal void Complement_VariousInputs_ReturnsExpectedResult(double input, double expected)
{
// Arrange
var function = TriangularFunction.Create(2, 3, 4);
var fuzzySet = new FuzzySet("some_fuzzy_state", function);
// Act
var result = fuzzySet.Complement(input);
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void GetMembership_VariousInputs_ReturnsExpectedResult(double input, double expected)
{
// Arrange
var function = TriangularFunction.Create(2, 3, 4);
var fuzzySet = new FuzzySet("some_fuzzy_state", function);
// Act
var result = fuzzySet.GetMembership(input);
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
Assert.Equal("some_fuzzy_state", fuzzySet.State.Value);
}
internal void Evaluate_WithVariousValidValues_ReturnsExpectedResult(
double membershipA,
double membershipB,
double expected)
{
// Arrange
var maximumTConorm = TriangularConormFactory.MaximumTConorm();
// Act
var result = maximumTConorm.Evaluate(UnitInterval.Create(membershipA), UnitInterval.Create(membershipB));
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void Intersection_VariousInputs_ReturnsExpectedResult(double input, double expected)
{
// Arrange
var function1 = TriangularFunction.Create(1, 3, 5);
var function2 = TriangularFunction.Create(2, 4, 6, 0, 0.75);
var fuzzySet1 = new FuzzySet("some_fuzzy_state1", function1);
var fuzzySet2 = new FuzzySet("some_fuzzy_state2", function2);
// Act
var result = fuzzySet1.Intersection(fuzzySet2, input);
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void Evaluate_WithVariousValidValues_ReturnsExpectedResult(
double membershipA,
double membershipB,
double expected)
{
// Arrange
var lukasiewicz = TriangularNormFactory.Lukasiewicz();
// Act
var result = lukasiewicz.Evaluate(UnitInterval.Create(membershipA), UnitInterval.Create(membershipB));
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void Evaluate_WithVariousValidValues_ReturnsExpectedResult(
double membershipA,
double membershipB,
double expected)
{
// Arrange
var algebraicProduct = TriangularNormFactory.AlgebraicProduct();
// Act
var result = algebraicProduct.Evaluate(UnitInterval.Create(membershipA), UnitInterval.Create(membershipB));
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void CompareToDouble_WithVariousValues_ReturnsExpectedResult(
double value1,
double value2,
int expected)
{
// Arrange
var unitInterval = UnitInterval.Create(value1);
// Act
var result = unitInterval.CompareTo(value2);
// Assert
Assert.Equal(expected, 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);
}
internal void Evaluate_WithVariousValidValues_ReturnsExpectedResult(
double membershipA,
double membershipB,
double expected)
{
// Arrange
var hamacherSum = TriangularConormFactory.HamacherSum();
// Act
var result = hamacherSum.Evaluate(UnitInterval.Create(membershipA), UnitInterval.Create(membershipB));
// Assert
Assert.Equal(Math.Round(expected, 5), Math.Round(result.Value, 5));
}
internal void CreateWithLeftEdge_GetMembershipWithVariousInputs_ReturnsExpectedResult(
double x1,
double x2,
double input,
double expected)
{
// Arrange
var function = TrapezoidalFunction.CreateWithLeftEdge(x1, x2);
// Act
var result = function.GetMembership(input);
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
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 GetMembership_VariousInputs_ReturnsExpectedResult(
double x1,
double x2,
double x3,
double input,
double expected)
{
// Arrange
var function = TriangularFunction.Create(x1, x2, x3);
// Act
var result = function.GetMembership(input);
// Assert
Assert.Equal(UnitInterval.Create(expected), result);
}
internal void GetMembership_WithVariousInputs_ReturnsExpectedResult(double x, double expected)
{
// Arrange
var points = new FuzzyPoint[]
{
new FuzzyPoint(2, 0.5),
new FuzzyPoint(3, 1)
};
var function = new PiecewiseLinearFunction(points);
// Act
var result = function.GetMembership(x);
// Assert
Assert.Equal(UnitInterval.Create(expected), 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);
}
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);
}
internal void SubtractionOperator_WithVariousValues_ReturnsExpectedResult(
double value1,
double value2,
double expected)
{
// Arrange
var unitInterval1 = UnitInterval.Create(value1);
var unitInterval2 = UnitInterval.Create(value2);
// Act
var result1 = unitInterval1 - unitInterval2;
var result2 = value1 - unitInterval2;
var result3 = unitInterval1 - value2;
// Assert
Assert.Equal(expected, result1);
Assert.Equal(expected, result2);
Assert.Equal(expected, result3);
}
internal void LessThanOrEqualToOperator_WithVariousValues_ReturnsExpectedResult(
double value1,
double value2,
bool expected)
{
// Arrange
var unitInterval1 = UnitInterval.Create(value1);
var unitInterval2 = UnitInterval.Create(value2);
// Act
var result1 = unitInterval1 <= unitInterval2;
var result2 = value1 <= unitInterval2;
var result3 = unitInterval1 <= value2;
// Assert
Assert.Equal(expected, result1);
Assert.Equal(expected, result2);
Assert.Equal(expected, result3);
}