public float Evaluate(FuzzyValueSet set)
{
var val = MathFz.Clamp01(this.Expression.Evaluate(set));
float ret = 1.0f - val;
return(ret);
}
public float Evaluate(FuzzyValueSet set)
{
var val = MathFz.Clamp01(this.Expression.Evaluate(set));
val = (float)Math.Sqrt(val);
return(val);
}
public void TestFuzzyRule()
{
IMemebershipFunction coldFx, warmFx, hotFx;
this.GetMembershipFunctions(out coldFx, out warmFx, out hotFx);
FuzzyVariable <Temperature> cold = new FuzzyVariable <Temperature>(Temperature.Cold, coldFx);
FuzzyVariable <Temperature> warm = new FuzzyVariable <Temperature>(Temperature.Warm, warmFx);
FuzzyVariable <Temperature> hot = new FuzzyVariable <Temperature>(Temperature.Hot, hotFx);
var exp = cold.AsExpression().And(warm).Or(hot.AsExpression().Not());
FuzzyRule <Command> rule = new FuzzyRule <Command>(Command.Heat, exp);
float inputTemp = 10;
FuzzyValueSet valueSet = new FuzzyValueSet();
valueSet.Set(cold.fX(inputTemp));
valueSet.Set(warm.fX(inputTemp));
valueSet.Set(hot.fX(inputTemp));
// 0.6666 AND 0.3333 OR NOT 0.0
var result = rule.Evaluate(valueSet);
Assert.AreEqual(1.0f, result.membershipDegree, 0.000005f);
}
public float Evaluate(FuzzyValueSet set)
{
var valA = this.OperandA.Evaluate(set);
var valB = this.OperandB.Evaluate(set);
return(MathFz.Clamp01(Math.Max(valA, valB)));
}
public void TestRuleEvaluation()
{
var desirability = this.GetDesirabilitySet();
var distance = this.GetDistanceToTargetSet();
var ammo = this.GetAmmoStatusSet();
var rocketLaucherRules = this.GetRocketLauncherRules();
FuzzyValueSet inputs = new FuzzyValueSet();
distance.Evaluate(200f, inputs);
ammo.Evaluate(8f, inputs);
IRuleEvaluator <Desirability> ruleEvaluator = new RuleEvaluator <Desirability>();
var result = ruleEvaluator.EvaluateRules(new List <FuzzyRule <Desirability> >(rocketLaucherRules), inputs);
this.AssertFuzzyValue <Desirability>(Desirability.Desirable, 0.0f, result[0]);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.33f, result[1]);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.2f, result[2]);
this.AssertFuzzyValue <Desirability>(Desirability.VeryDesirable, 0.0f, result[3]);
this.AssertFuzzyValue <Desirability>(Desirability.VeryDesirable, 0.67f, result[4]);
this.AssertFuzzyValue <Desirability>(Desirability.Desirable, 0.2f, result[5]);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.0f, result[6]);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.0f, result[7]);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.0f, result[8]);
}
public void FuzzyNot_01()
{
FuzzyValue <Temperature> val01 = new FuzzyValue <Temperature>(Temperature.Cold, 0.8f);
FuzzyValue <Temperature> val02 = new FuzzyValue <Temperature>(Temperature.Warm, 0.25f);
FuzzyValueSet set = new FuzzyValueSet();
set.Set(val01);
set.Set(val02);
FuzzyNot exp = new FuzzyNot(new FuzzyVariableExpression <Temperature>(Temperature.Cold));
var result = exp.Evaluate(set);
Assert.AreEqual(0.2f, result, 0.000005);
}
public void TestFuzzySet_Simple()
{
FuzzyValueSet set = new FuzzyValueSet();
FuzzyValue <Temperature> value = new FuzzyValue <Temperature>()
{
linguisticVariable = Temperature.Hot, membershipDegree = 0.5f
};
set.Set(value);
var result = set.Get(Temperature.Hot);
Assert.AreEqual(Temperature.Hot, result.linguisticVariable);
Assert.AreEqual(0.5f, result.membershipDegree);
}
public void TestInference()
{
var desirability = this.GetDesirabilitySet();
var distance = this.GetDistanceToTargetSet();
var ammo = this.GetAmmoStatusSet();
var rocketRuleSet = this.GetRocketLauncherRuleSet(desirability);
FuzzyValueSet inputs = new FuzzyValueSet();
distance.Evaluate(200f, inputs);
ammo.Evaluate(8f, inputs);
var result = rocketRuleSet.Evaluate(inputs);
Assert.AreEqual(60.625f, result, 0.25f);
}
public void TestMaxAvDefuzzer()
{
var desirability = this.GetDesirabilitySet();
FuzzyValueSet mergedValues = new FuzzyValueSet();
mergedValues.Set(new FuzzyValue <Desirability>(Desirability.Undesirable, 0.33f));
mergedValues.Set(new FuzzyValue <Desirability>(Desirability.Desirable, 0.2f));
mergedValues.Set(new FuzzyValue <Desirability>(Desirability.VeryDesirable, 0.67f));
IDefuzzer <Desirability> defuzzer = new MaxAvDefuzzer <Desirability>();
var result = defuzzer.Defuzze(desirability, mergedValues);
Assert.AreEqual(60.625f, result, 0.0005f);
}
public FuzzyValue <T>[] EvaluateRules(List <FuzzyRule <T> > rules, FuzzyValueSet inputValueSet)
{
int ruleCount = rules.Count;
if (this.ruleOutputs == null || (this.ruleOutputs != null && this.ruleOutputs.Length < ruleCount))
{
this.ruleOutputs = new FuzzyValue <T> [ruleCount];
}
else
{
this.ClearOutputs();
}
for (int i = 0; i < ruleCount; i++)
{
this.ruleOutputs[i] = rules[i].Evaluate(inputValueSet);
}
return(this.ruleOutputs);
}
public void TestFuzzySet_DiffEnum_A()
{
FuzzyValueSet set = new FuzzyValueSet();
FuzzyValue <Temperature> value01 = new FuzzyValue <Temperature>()
{
linguisticVariable = Temperature.Hot, membershipDegree = 0.5f
};
FuzzyValue <Command> value02 = new FuzzyValue <Command>()
{
linguisticVariable = Command.Heat, membershipDegree = 1f
};
set.Set(value02);
set.Set(value01);
var result = set.Get(Temperature.Hot);
Assert.AreEqual(Temperature.Hot, result.linguisticVariable);
Assert.AreEqual(0.5f, result.membershipDegree);
}
public float Defuzze(FuzzySet <T> outputVariableSet, FuzzyValueSet fuzzyValues)
{
float sumRepValConf = 0.0f;
float sumConf = 0.0f;
FuzzyVariable <T> fuzzyVar = null;
FuzzyValue <T> value;
for (int i = 0; i < this.outputEnumValues.Length; i++)
{
T linguisticVar = this.outputEnumValues[i];
value = fuzzyValues.Get(linguisticVar);
if (value.Confidence <= 0.0f)
{
continue;
}
fuzzyVar = outputVariableSet.Get(linguisticVar);
sumRepValConf += (fuzzyVar.MembershipFunction.RepresentativeValue * value.Confidence);
sumConf += value.Confidence;
}
return(sumRepValConf / sumConf);
}
public void MergeValues(FuzzyValue <T>[] values, FuzzyValueSet mergedOutputs)
{
this.CollapseOutputs(values);
float maxValue = 0.0f;
FuzzyValue <T> value;
List <FuzzyValue <T> > duplicateList = null;
for (int i = 0; i < this.outputEnumValues.Length; i++)
{
maxValue = 0.0f;
duplicateList = this.duplicateOutputs[EnumKey.From(this.outputEnumValues[i])];
for (int j = 0; j < duplicateList.Count; j++)
{
value = duplicateList[j];
if (value.membershipDegree > maxValue) //Or-ing outputs
{
maxValue = value.membershipDegree;
}
}
mergedOutputs.Set(new FuzzyValue <T>(this.outputEnumValues[i], maxValue));
duplicateList.Clear();
}
}
public void TestValueMergeByOr()
{
var desirability = this.GetDesirabilitySet();
var distance = this.GetDistanceToTargetSet();
var ammo = this.GetAmmoStatusSet();
var rocketLaucherRules = this.GetRocketLauncherRules();
FuzzyValueSet inputs = new FuzzyValueSet();
distance.Evaluate(200f, inputs);
ammo.Evaluate(8f, inputs);
IRuleEvaluator <Desirability> ruleEvaluator = new RuleEvaluator <Desirability>();
var ruleOutputs = ruleEvaluator.EvaluateRules(new List <FuzzyRule <Desirability> >(rocketLaucherRules), inputs);
IFuzzyValuesMerger <Desirability> merger = new CachedOutputsFuzzyValuesMerger <Desirability>();
FuzzyValueSet mergedValues = new FuzzyValueSet();
merger.MergeValues(ruleOutputs, mergedValues);
this.AssertFuzzyValue <Desirability>(Desirability.Undesirable, 0.33f, mergedValues.Get(Desirability.Undesirable));
this.AssertFuzzyValue <Desirability>(Desirability.Desirable, 0.2f, mergedValues.Get(Desirability.Desirable));
this.AssertFuzzyValue <Desirability>(Desirability.VeryDesirable, 0.67f, mergedValues.Get(Desirability.VeryDesirable));
}
public float Evaluate(FuzzyValueSet set)
{
var fuzzyVar = set.Get(this.LinguisticVariable);
return(MathFz.Clamp01(fuzzyVar.membershipDegree));
}
