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 Defuzzify_WithTwoTriangles_ReturnsExpectedResult()
{
// Arrange
var fuzzySet1 = new FuzzySet("left", TriangularFunction.Create(1, 2, 3));
var fuzzySet2 = new FuzzySet("right", TriangularFunction.Create(3, 4, 5));
var fuzzyOutput = new List <FuzzyOutput>
{
new FuzzyOutput(
Label.Create("Balance"),
fuzzySet1,
UnitInterval.One()),
new FuzzyOutput(
Label.Create("Balance"),
fuzzySet2,
UnitInterval.One())
};
var centroidDefuzzifier = new CentroidDefuzzifier();
// Act
var result = centroidDefuzzifier.Defuzzify(fuzzyOutput);
// Assert
Assert.Equal("Balance", result.Subject.Value);
Assert.Equal(3, result.Value);
}
public UnitInterval Evaluate(UnitInterval membershipA, UnitInterval membershipB)
{
return(1 - (membershipA * membershipB) > 0
? UnitInterval.Create(
((membershipA + membershipB) - (2 * (membershipA * membershipB)))
/ (1 - (membershipA * membershipB)))
: UnitInterval.One());
}
internal void One_ReturnsUnitIntervalWithValueOne()
{
// Arrange
// Act
var result = UnitInterval.One();
// Assert
Assert.Equal(1, result.Value);
}
internal void MaxY_ReturnsExpectedResult()
{
// Arrange
var function = SingletonFunction.Create(1);
// Act
var result = function.MaxY;
// Assert
Assert.Equal(UnitInterval.One(), result);
}
internal void ToString_ReturnsExpectedResults()
{
// Arrange
// Act
var result1 = UnitInterval.Zero().ToString();
var result2 = UnitInterval.One().ToString();
// Assert
Assert.Equal("0", result1);
Assert.Equal("1", result2);
}
internal void GetHashCode_ReturnsExpectedResults()
{
// Arrange
// Act
var result1 = UnitInterval.Zero().GetHashCode();
var result2 = UnitInterval.One().GetHashCode();
// Assert
Assert.Equal(0, result1);
Assert.Equal(1072693248, result2);
}
internal void Equals_WhenValueNull_ReturnsFalse()
{
// Arrange
var unitInterval = UnitInterval.One();
// Act
var result = unitInterval.Equals(null);
// Assert
Assert.False(result);
}
internal void Equals_WhenValueNotEqual_ReturnsFalse()
{
// Arrange
var unitInterval = UnitInterval.One();
// Act
var result1 = unitInterval.Equals(UnitInterval.Zero());
var result2 = unitInterval.Equals(0);
// Assert
Assert.False(result1);
Assert.False(result2);
}
internal void Equals_WhenValueEqual_ReturnsTrue()
{
// Arrange
var unitInterval = UnitInterval.One();
// Act
var result1 = unitInterval.Equals(UnitInterval.One());
var result2 = unitInterval.Equals(1.0);
// Assert
Assert.True(result1);
Assert.True(result2);
}
internal void MaxY_ReturnsExpectedResult()
{
// Arrange
// Arrange
var points = new FuzzyPoint[]
{
new FuzzyPoint(2, 0),
new FuzzyPoint(3, 1)
};
var function = new PiecewiseLinearFunction(points);
// Act
var result = function.MaxY;
// Assert
Assert.Equal(UnitInterval.One(), 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);
}
internal void Defuzzify_WhenSubjectsUnrelated_Throws()
{
// Arrange
var fuzzySet = new FuzzySet("centre", TriangularFunction.Create(-1, 0, 1));
var fuzzyOutput = new List <FuzzyOutput>
{
new FuzzyOutput(
Label.Create("Subject1"),
fuzzySet,
UnitInterval.One()),
new FuzzyOutput(
Label.Create("Subject2"),
fuzzySet,
UnitInterval.One())
};
var centroidDefuzzifier = new CentroidDefuzzifier();
// Act
// Assert
Assert.Throws <InvalidOperationException>(() => centroidDefuzzifier.Defuzzify(fuzzyOutput));
}
public UnitInterval Evaluate(UnitInterval membershipA, UnitInterval membershipB)
{
return(Math.Min(membershipA.Value, membershipB.Value).Equals(0)
? UnitInterval.Create(Math.Max(membershipA.Value, membershipB.Value))
: UnitInterval.One());
}
/// <summary>
/// Prevents a default instance of the <see cref="ConditionBuilder"/> class from being created.
/// </summary>
/// <returns>
/// A <see cref="ConditionBuilder"/>.
/// </returns>
private ConditionBuilder()
{
this.Weight = UnitInterval.One();
}