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); }